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                 /*tcDisplayPNGCharacteristics*/
1400                 if (ass_data->tc_disp_char_list != NULL) {
1401                         json_builder_set_member_name(builder, "tcDisplayPNGCharacteristics");
1402                         json_builder_begin_array(builder);
1403
1404                         GList *iter = g_list_first(ass_data->tc_disp_char_list);
1405                         while (iter != NULL) {
1406
1407                                 fido_display_png_characteristics_descriptor_s *png_data =
1408                                                 (fido_display_png_characteristics_descriptor_s*) (iter->data);
1409
1410                                 if (png_data != NULL) {
1411
1412                                         json_builder_begin_object(builder);
1413
1414                                         __add_int_to_json_object(builder, _JSON_KEY_WIDTH, png_data->width);
1415                                         __add_int_to_json_object(builder, _JSON_KEY_HEIGHT, png_data->height);
1416                                         __add_int_to_json_object(builder, _JSON_KEY_BIT_DEPTH, png_data->bit_depth);
1417                                         __add_int_to_json_object(builder, _JSON_KEY_COLOR_TYPE, png_data->color_type);
1418                                         __add_int_to_json_object(builder, _JSON_KEY_COMPRESSION, png_data->compression);
1419                                         __add_int_to_json_object(builder, _JSON_KEY_FILTER, png_data->filter);
1420                                         __add_int_to_json_object(builder, _JSON_KEY_INTERLACE, png_data->interlace);
1421
1422
1423                                         if (png_data->plte != NULL) {
1424                                                 /*plte array start*/
1425
1426                                                 json_builder_set_member_name(builder, _JSON_KEY_PLTE);
1427                                                 json_builder_begin_array(builder);
1428
1429                                                 GList *plte_iter = g_list_first(png_data->plte);
1430                                                 while (plte_iter != NULL) {
1431
1432                                                         fido_rgb_pallette_entry_s *plte_data = (fido_rgb_pallette_entry_s*)(plte_iter->data);
1433                                                         if (plte_data != NULL) {
1434                                                                 json_builder_begin_object(builder);
1435
1436                                                                 __add_int_to_json_object(builder, _JSON_KEY_R, plte_data->r);
1437                                                                 __add_int_to_json_object(builder, _JSON_KEY_G, plte_data->g);
1438                                                                 __add_int_to_json_object(builder, _JSON_KEY_B, plte_data->b);
1439
1440                                                                 json_builder_end_object(builder);
1441                                                         }
1442
1443                                                         plte_iter = plte_iter->next;
1444                                                 }
1445
1446                                                 json_builder_end_array(builder);
1447
1448                                                 /*plte array end*/
1449                                         }
1450
1451                                         json_builder_end_object(builder);
1452                                 }
1453
1454                                 iter = iter->next;
1455                         }
1456
1457                         json_builder_end_array(builder);
1458                 }
1459
1460         json_builder_end_object(builder);
1461
1462         assertions_iter = assertions_iter->next;
1463
1464     }
1465
1466     json_builder_end_array(builder);
1467
1468     json_builder_end_object(builder);
1469
1470
1471     json_builder_end_array(builder);
1472
1473
1474     JsonNode *root_builder = json_builder_get_root(builder);
1475
1476     JsonGenerator *gen = json_generator_new();
1477     json_generator_set_root(gen, root_builder);
1478
1479     json_node_free(root_builder);
1480     g_object_unref(builder);
1481
1482     gsize len = 0;
1483     char *json = json_generator_to_data(gen, &len);
1484     if (json != NULL) {
1485         *uaf_response = json;
1486         _INFO("_uaf_composer_compose_uaf_process_response_reg return success");
1487
1488         if (gen != NULL)
1489             g_object_unref(gen);
1490
1491         return FIDO_ERROR_NONE;
1492     }
1493
1494     _INFO("_uaf_composer_compose_uaf_process_response_reg return fail");
1495     g_object_unref(gen);
1496     return FIDO_ERROR_PROTOCOL_ERROR;
1497 }
1498
1499 int
1500 _uaf_composer_compose_uaf_process_response_auth(_op_header_t *header, char *final_ch, GList *assertions, char **uaf_response)
1501 {
1502     return _uaf_composer_compose_uaf_process_response_reg(header, final_ch, assertions, uaf_response);
1503 }
1504
1505 char *
1506 _uaf_composer_compose_dereg_request(_response_t *uaf_res)
1507 {
1508     _INFO("_uaf_composer_compose_dereg_request");
1509
1510     /*Only 1.0 protocol support*/
1511
1512     JsonBuilder *builder = json_builder_new();
1513
1514     JsonBuilder *root_array = json_builder_begin_array(builder);
1515
1516     JsonBuilder *uaf_1_root = json_builder_begin_object(root_array);
1517
1518     /* header*/
1519     json_builder_set_member_name(uaf_1_root, _JSON_KEY_HEADER);
1520     JsonBuilder *header_root = json_builder_begin_object(uaf_1_root);
1521
1522     json_builder_set_member_name(header_root, _JSON_KEY_APPID);
1523     json_builder_add_string_value(header_root, uaf_res->header->app_id);
1524
1525     json_builder_set_member_name(header_root, _JSON_KEY_OP);
1526     json_builder_add_string_value(header_root, strdup(_UAF_OPERATION_NAME_KEY_DE_REG));
1527
1528     json_builder_set_member_name(header_root, _JSON_KEY_SERVER_DATA);
1529     json_builder_add_string_value(header_root, uaf_res->header->server_data);
1530
1531     json_builder_set_member_name(header_root, _JSON_KEY_UPV);
1532     JsonBuilder *upv_root = json_builder_begin_object(header_root);
1533
1534     json_builder_set_member_name(upv_root, _JSON_KEY_MAJOR);
1535     json_builder_add_int_value(upv_root, uaf_res->header->version->major);
1536
1537     json_builder_set_member_name(upv_root, _JSON_KEY_MINOR);
1538     json_builder_add_int_value(upv_root,uaf_res->header->version->minor);
1539
1540     json_builder_end_object(upv_root);
1541
1542     json_builder_end_object(header_root);
1543     /* header*/
1544
1545     _INFO("after header");
1546
1547
1548     /*appID*/
1549     if (uaf_res->header->app_id == NULL) {
1550         _ERR("appID is missing");
1551
1552         g_object_unref(builder);
1553         return NULL;
1554     }
1555
1556     json_builder_set_member_name(uaf_1_root, _JSON_KEY_APPID);
1557     json_builder_add_string_value(uaf_1_root, uaf_res->header->app_id);
1558     /*appID*/
1559
1560
1561     /*authenticators*/
1562     json_builder_set_member_name(uaf_1_root, _JSON_KEY_AUTHENTICATORS_SMALL);
1563     JsonBuilder *auth_root = json_builder_begin_array(uaf_1_root);
1564     GList *assertions_iter = g_list_first(uaf_res->assertion_list);
1565     while (assertions_iter != NULL) {
1566
1567         _auth_reg_assertion_t *ass_data = (_auth_reg_assertion_t*)(assertions_iter->data);
1568
1569         char *assrt = ass_data->assertion;
1570
1571         _INFO("%s", assrt);
1572
1573         _auth_reg_assertion_tlv_t *assrt_tlv = _tlv_util_decode_reg_assertion(assrt);
1574         if (assrt_tlv == NULL) {
1575             _ERR("Invalid assertion format");
1576
1577             g_object_unref(builder);
1578             return NULL;
1579         }
1580
1581         char *aaid = strdup(assrt_tlv->aaid);
1582
1583         JsonBuilder *obj = json_builder_begin_object(auth_root);
1584
1585         if (aaid != NULL) {
1586             json_builder_set_member_name(obj, _JSON_KEY_AAID);
1587             json_builder_add_string_value(obj, aaid);
1588             _INFO("aaid=[%s]", aaid);
1589         }
1590
1591         if (assrt_tlv->key_id != NULL) {
1592             int inlen = assrt_tlv->key_id_len;
1593             int enc_len = (4 * ((inlen + 2) / 3)) + 1;
1594
1595             unsigned char *key_id_enc = calloc(1, enc_len);
1596
1597             int r = _fido_b64url_encode(assrt_tlv->key_id, inlen, key_id_enc, &enc_len);
1598
1599             _INFO("_fido_b64url_encode len=[%d]", enc_len);
1600
1601             if ((key_id_enc != NULL) && (r == 0)) {
1602                 _INFO("_fido_b64url_encoded string=%s", key_id_enc);
1603                 json_builder_set_member_name(obj, _JSON_KEY_KEY_ID);
1604                 json_builder_add_string_value(obj, (char *)key_id_enc);
1605                 _INFO("keyid=[%s]", key_id_enc);
1606             }
1607
1608         }
1609
1610         _INFO("after assertions");
1611
1612         _free_auth_reg_assertion_tlv(assrt_tlv);
1613
1614         json_builder_end_object(obj);
1615
1616
1617         assertions_iter = assertions_iter->next;
1618
1619     }
1620
1621     json_builder_end_array(auth_root);
1622     /*authenticators*/
1623
1624
1625     json_builder_end_object(uaf_1_root);
1626
1627
1628     json_builder_end_array(root_array);
1629
1630
1631     JsonNode *root_builder = json_builder_get_root(builder);
1632     JsonGenerator *gen = json_generator_new();
1633     json_generator_set_root(gen, root_builder);
1634
1635     json_node_free(root_builder);
1636     g_object_unref(builder);
1637
1638     gsize len = 0;
1639     char *dereg_json = json_generator_to_data(gen, &len);
1640     g_object_unref(gen);
1641
1642     if (dereg_json != NULL) {
1643         _INFO("_uaf_composer_compose_dereg_request return success");
1644         _INFO("%s", dereg_json);
1645         return dereg_json;
1646     }
1647
1648     _INFO("_uaf_composer_compose_dereg_request return fail");
1649     return NULL;
1650 }
1651
1652 static _policy_t*
1653 __get_policy(JsonObject *uaf_object)
1654 {
1655     /*TODO : Check in spec whether accepted array can be NULL, i.e allow all?*/
1656
1657     JsonObject *policy_obj = json_object_get_object_member(uaf_object, _JSON_KEY_POLICY);
1658     RET_IF_FAIL(policy_obj != NULL, NULL);
1659
1660     JsonArray *accepted_array = json_object_get_array_member(policy_obj, _JSON_KEY_ACCEPTED);
1661     RET_IF_FAIL(accepted_array != NULL, NULL);
1662
1663     int accepted_len = json_array_get_length(accepted_array);
1664    _INFO("Parser accepted list count [%d]", accepted_len);
1665
1666     _policy_t *policy_info = (_policy_t *)calloc(1, sizeof(_policy_t));
1667     policy_info->is_keyid_present = false;
1668
1669     GList *allowed_list = NULL;
1670
1671     int i = 0;
1672     for (i = 0; i < accepted_len; i++) {
1673
1674         JsonArray *accepted_arr_inner = json_array_get_array_element(accepted_array, i);
1675         if (accepted_arr_inner) {
1676             int accepted_len_inner = json_array_get_length(accepted_arr_inner);
1677             _INFO("Parser accepted list inner count [%d]", accepted_len_inner);
1678
1679             int j = 0;
1680             for (j = 0; j < accepted_len_inner; j++) {
1681                 GList *allowed_list_inner = NULL;
1682
1683                 JsonObject *match_obj = json_array_get_object_element(accepted_arr_inner, j);
1684                 if (match_obj) {
1685                     _match_criteria_t *match_info = _uaf_parser_parse_match(match_obj);
1686                     if (match_info) {
1687                         _INFO("Appending match_info");
1688                         if (policy_info->is_keyid_present == false) {
1689                             if (match_info->key_id_list != NULL)
1690                                 policy_info->is_keyid_present = true;
1691                         }
1692                         allowed_list_inner = g_list_append(allowed_list_inner, match_info);
1693                     }
1694                 }
1695                 if (j == (accepted_len_inner - 1)) {
1696                     if (allowed_list_inner) {
1697                         _INFO("Appending accepted list");
1698                         allowed_list = g_list_append(allowed_list, allowed_list_inner);
1699                     }
1700                 }
1701             }
1702         }
1703     }
1704
1705     if (allowed_list != NULL)
1706         policy_info->accepted_list = g_list_first(allowed_list);
1707
1708     GList *disallowed_list = NULL;
1709
1710     JsonArray *disallowed_array = json_object_get_array_member(policy_obj, _JSON_KEY_DISALLOWED);
1711     if (disallowed_array != NULL) {
1712         int disallowed_len = json_array_get_length(disallowed_array);
1713
1714         for (i = 0; i < disallowed_len; i++) {
1715             JsonObject *match_obj = json_array_get_object_element(disallowed_array, i);
1716             if (match_obj) {
1717
1718                 _match_criteria_t *match_info = _uaf_parser_parse_match(match_obj);
1719                 if (match_info) {
1720                     if (policy_info->is_keyid_present == false) {
1721                         if (match_info->key_id_list != NULL)
1722                             policy_info->is_keyid_present = true;
1723                     }
1724                     disallowed_list = g_list_append(disallowed_list, match_info);
1725                 }
1726             }
1727         }
1728
1729         if (disallowed_list != NULL)
1730             policy_info->disallowed_list = g_list_first(disallowed_list);
1731     }
1732
1733     _INFO("returning policy [%p]", policy_info);
1734     return policy_info;
1735 }
1736
1737 static _reg_request_t*
1738 __parse_uaf_reg_message(JsonObject *uaf_object)
1739 {
1740         _reg_request_t *reg_req_temp = (_reg_request_t *)calloc(1, sizeof(_reg_request_t));
1741
1742         reg_req_temp->challenge = __get_string_from_json_object(uaf_object, _JSON_KEY_CHALLENGE);
1743
1744         reg_req_temp->user_name = __get_string_from_json_object(uaf_object, _JSON_KEY_USER_NAME);
1745
1746         reg_req_temp->policy = __get_policy(uaf_object);
1747         if (reg_req_temp->policy != NULL)
1748             _INFO("parsed policy [%p]", reg_req_temp->policy);
1749         else
1750             _INFO("parsed policy [NULL]");
1751
1752         return reg_req_temp;
1753 }
1754
1755 static GList*
1756 __get_transaction_list(JsonObject *uaf_obj)
1757 {
1758     RET_IF_FAIL(uaf_obj != NULL, NULL);
1759
1760     JsonArray *tr_arr = json_object_get_array_member(uaf_obj, _JSON_KEY_TRANSACTION);
1761     RET_IF_FAIL(tr_arr != NULL, NULL);
1762
1763     _INFO("");
1764
1765     GList *trans_list = NULL;
1766
1767     int tr_arr_len = json_array_get_length(tr_arr);
1768     int i = 0;
1769     for (; i< tr_arr_len; i++) {
1770         JsonObject *tr_obj = json_array_get_object_element(tr_arr, i);
1771         if (tr_obj != NULL) {
1772
1773             _auth_transaction_t *trans = calloc(1, sizeof(_auth_transaction_t));
1774
1775             trans->content_type = __get_string_from_json_object(tr_obj, _JSON_KEY_CONTENT_TYPE);
1776             trans->content = __get_string_from_json_object(tr_obj, _JSON_KEY_CONTENT);
1777
1778             /*tcDisplayPNGCharacteristics*/
1779             JsonObject *tc_disp_obj = json_object_get_object_member(tr_obj, _JSON_KEY_TC_DISP_PNG_CHARS);
1780             if (tc_disp_obj != NULL) {
1781                 trans->display_charac = __get_png_data(tr_obj);
1782             }
1783
1784             trans_list = g_list_append(trans_list, trans);
1785         }
1786     }
1787
1788     if (trans_list != NULL) {
1789         trans_list = g_list_first(trans_list);
1790         _INFO("Transaction list count = [%d]", g_list_length(trans_list));
1791     }
1792
1793     _INFO("");
1794     return trans_list;
1795 }
1796
1797 static _auth_request_t*
1798 __parse_uaf_auth_message(JsonObject *uaf_object)
1799 {
1800     _auth_request_t *auth_req_temp = (_auth_request_t *)calloc(1, sizeof(_auth_request_t));
1801
1802     auth_req_temp->challenge = __get_string_from_json_object(uaf_object, _JSON_KEY_CHALLENGE);
1803
1804     auth_req_temp->transaction_list = __get_transaction_list(uaf_object);
1805
1806     auth_req_temp->policy = __get_policy(uaf_object);
1807
1808     if (auth_req_temp->policy != NULL)
1809         _INFO("parsed policy [%p]", auth_req_temp->policy);
1810     else
1811         _INFO("parsed policy [NULL]");
1812
1813     return auth_req_temp;
1814 }
1815
1816 static void
1817 __dereg_auth_parser(JsonArray *array, guint index_, JsonNode *element_node, gpointer user_data)
1818 {
1819      _dereg_request_t *dereg_req_temp = (_dereg_request_t *)user_data;
1820
1821      JsonObject *auth_obj = json_node_get_object(element_node);
1822      if (auth_obj != NULL) {
1823          _dereg_auth_info_t *dereg_auth = (_dereg_auth_info_t*)calloc(1, sizeof(_dereg_auth_info_t));
1824
1825          dereg_auth->aaid = __get_string_from_json_object(auth_obj, _JSON_KEY_AAID);
1826          dereg_auth->key_id = __get_string_from_json_object(auth_obj, _JSON_KEY_KEY_ID);
1827
1828          dereg_req_temp->auth_info_list = g_list_append(dereg_req_temp->auth_info_list, dereg_auth);
1829      }
1830 }
1831
1832 static _dereg_request_t*
1833 __parse_uaf_dereg_message(JsonObject *uaf_object)
1834 {
1835     _dereg_request_t *dereg_req_temp = (_dereg_request_t *)calloc(1, sizeof(_dereg_request_t));
1836
1837     JsonArray *auth_arr = json_object_get_array_member(uaf_object, _JSON_KEY_AUTHENTICATORS_SMALL);
1838     if (auth_arr != NULL) {
1839         json_array_foreach_element(auth_arr, __dereg_auth_parser, dereg_req_temp);
1840     }
1841
1842     return dereg_req_temp;
1843 }
1844
1845 _message_t *
1846 _uaf_parser_parse_message(const char *uaf_json, const gchar *channel_binding)
1847 {
1848     _INFO("_uaf_parser_parse_message");
1849
1850     RET_IF_FAIL(uaf_json != NULL, NULL);
1851
1852     _message_t *uaf_message_temp = (_message_t*) calloc(1, sizeof(_message_t));
1853     uaf_message_temp->type = _MESSAGE_TYPE_MIN;
1854
1855     if (channel_binding != NULL) {
1856         if (strcmp(channel_binding, _FIDO_NO_CHANNEL_BINDING_DBUS_STRING) != 0)
1857             uaf_message_temp->channel_binding = strdup(channel_binding);
1858     }
1859
1860     JsonParser *parser = json_parser_new();
1861     CATCH_IF_FAIL(parser != NULL);
1862
1863     GError *parse_err = NULL;
1864     json_parser_load_from_data(parser, uaf_json, -1, &parse_err);
1865     CATCH_IF_FAIL(parse_err == NULL);
1866
1867     JsonNode *root = json_parser_get_root(parser);
1868     CATCH_IF_FAIL(root != NULL);
1869
1870     JsonArray *uaf_array = json_node_get_array(root);
1871     CATCH_IF_FAIL(uaf_array != NULL);
1872
1873     /* Parse all and accept only 1.0 version */
1874
1875     int uaf_arr_len = json_array_get_length(uaf_array);
1876     if (uaf_arr_len <= 0) {
1877         _ERR("No UAF message found");
1878
1879         _free_message(uaf_message_temp);
1880         g_object_unref(parser);
1881         return NULL;
1882     }
1883
1884     int i = 0;
1885     for (; i < uaf_arr_len ; i++) {
1886         JsonObject *uaf_object = json_array_get_object_element(uaf_array, i);
1887         CATCH_IF_FAIL(uaf_object != NULL);
1888
1889         JsonObject *header_obj = json_object_get_object_member(uaf_object, _JSON_KEY_HEADER);
1890         CATCH_IF_FAIL(header_obj != NULL);
1891
1892         uaf_message_temp->header = __parse_uaf_header(header_obj);
1893
1894         /* NULL signifies the header version is not 1.0 */
1895         if (uaf_message_temp->header == NULL)
1896             continue;
1897
1898         if (strcmp(uaf_message_temp->header->operation, _UAF_OPERATION_NAME_KEY_REG) == 0){
1899             uaf_message_temp->data = (void *)__parse_uaf_reg_message(uaf_object);
1900             if (uaf_message_temp->data == NULL) {
1901
1902                 _free_message(uaf_message_temp);
1903                 g_object_unref(parser);
1904
1905                 return NULL;
1906             }
1907             else {
1908                 uaf_message_temp->type = _MESSAGE_TYPE_REG;
1909
1910                 g_object_unref(parser);
1911
1912                 return uaf_message_temp;
1913             }
1914         }
1915
1916         if (strcmp(uaf_message_temp->header->operation, _UAF_OPERATION_NAME_KEY_AUTH) == 0){
1917             uaf_message_temp->data = (void *)__parse_uaf_auth_message(uaf_object);
1918             if (uaf_message_temp->data == NULL) {
1919
1920                 _free_message(uaf_message_temp);
1921                 g_object_unref(parser);
1922
1923                 return NULL;
1924             }
1925             else {
1926                uaf_message_temp->type = _MESSAGE_TYPE_AUTH;
1927
1928                g_object_unref(parser);
1929                return uaf_message_temp;
1930
1931             }
1932         }
1933
1934         if (strcmp(uaf_message_temp->header->operation, _UAF_OPERATION_NAME_KEY_DE_REG) == 0){
1935             uaf_message_temp->data = (void *)__parse_uaf_dereg_message(uaf_object);
1936             if (uaf_message_temp->data == NULL) {
1937
1938                 _free_message(uaf_message_temp);
1939                 g_object_unref(parser);
1940
1941                 return NULL;
1942             }
1943             else {
1944                 uaf_message_temp->type = _MESSAGE_TYPE_DEREG;
1945
1946                 g_object_unref(parser);
1947                 return uaf_message_temp;
1948             }
1949         }
1950
1951     }
1952
1953 CATCH:
1954     _free_message(uaf_message_temp);
1955     if (parser != NULL)
1956         g_object_unref(parser);
1957
1958     return NULL;
1959 }
1960
1961 GList *
1962 _uaf_parser_parse_trusted_facets(const char *json)
1963 {
1964     JsonParser *parser = json_parser_new();
1965
1966     gsize len = -1;
1967     GError *err = NULL;
1968
1969     GList *app_id_list = NULL;
1970
1971     bool is_parsed = json_parser_load_from_data(parser, json, len, &err);
1972     CATCH_IF_FAIL(is_parsed == TRUE);
1973
1974
1975     JsonNode *root = json_parser_get_root(parser);
1976
1977     JsonObject *root_obj = json_node_get_object(root);
1978     CATCH_IF_FAIL(root_obj != NULL);
1979
1980     JsonArray *facet_arr = json_object_get_array_member(root_obj, _JSON_KEY_TRUSTED_FACETS);
1981     CATCH_IF_FAIL(facet_arr != NULL);
1982
1983     int facet_arr_len = json_array_get_length(facet_arr);
1984
1985     int i = 0;
1986     for (; i < facet_arr_len; i++) {
1987         JsonObject *facet_obj = json_array_get_object_element(facet_arr, i);
1988         if (facet_obj != NULL) {
1989
1990             JsonObject *ver_obj = json_object_get_object_member(facet_obj, _JSON_KEY_VERSION);
1991             if (ver_obj != NULL) {
1992                 int major = _INVALID_INT;
1993                 int minor = _INVALID_INT;
1994
1995                 major = json_object_get_int_member(ver_obj, _JSON_KEY_MAJOR);
1996                 minor = json_object_get_int_member(ver_obj, _JSON_KEY_MINOR);
1997
1998                 if (major == _VERSION_MAJOR && minor == _VERSION_MINOR) {
1999                     JsonArray *id_arr = json_object_get_array_member(facet_obj, _JSON_KEY_IDS);
2000                     if (id_arr != NULL) {
2001                         int id_arr_len = json_array_get_length(id_arr);
2002
2003                         int idx = 0;
2004                         for (; idx < id_arr_len; idx++) {
2005                             const char *id = json_array_get_string_element(id_arr, idx);
2006                             if (id != NULL) {
2007                                 app_id_list = g_list_append(app_id_list, strdup(id));
2008                             }
2009                         }
2010                     }
2011                 }
2012             }
2013         }
2014     }
2015
2016 CATCH:
2017     if (parser != NULL)
2018         g_object_unref(parser);
2019
2020     if (app_id_list != NULL)
2021         app_id_list = g_list_first(app_id_list);
2022
2023     return app_id_list;
2024 }
2025
2026 _response_t*
2027 _uaf_parser_parse_uaf_response(const char *uaf_response)
2028 {
2029     RET_IF_FAIL(uaf_response != NULL, NULL);
2030
2031     _response_t *uaf_res_temp = (_response_t*) calloc(1, sizeof(_response_t));
2032
2033     JsonParser *parser = json_parser_new();
2034     CATCH_IF_FAIL(parser != NULL);
2035
2036     GError *parse_err = NULL;
2037     json_parser_load_from_data(parser, uaf_response, -1, &parse_err);
2038     CATCH_IF_FAIL(parse_err == NULL);
2039
2040     JsonNode *root = json_parser_get_root(parser);
2041     CATCH_IF_FAIL(root != NULL);
2042
2043     JsonArray *uaf_array = json_node_get_array(root);
2044     CATCH_IF_FAIL(uaf_array != NULL);
2045
2046     /* Parse all and accept only 1.0 version */
2047
2048     int uaf_arr_len = json_array_get_length(uaf_array);
2049     CATCH_IF_FAIL(uaf_arr_len > 0);
2050
2051     int i = 0;
2052     for (; i < uaf_arr_len ; i++) {
2053         JsonObject *uaf_object = json_array_get_object_element(uaf_array, i);
2054         CATCH_IF_FAIL(uaf_object != NULL);
2055
2056         JsonObject *header_obj = json_object_get_object_member(uaf_object, _JSON_KEY_HEADER);
2057         CATCH_IF_FAIL(header_obj != NULL);
2058
2059         uaf_res_temp->header = __parse_uaf_header(header_obj);
2060
2061         /* NULL signifies the header version is not 1.0 */
2062         if (uaf_res_temp->header == NULL)
2063             continue;
2064
2065         char *op = uaf_res_temp->header->operation;
2066
2067         /*Only process reg and auth responses*/
2068         if ((strcmp(op, _UAF_OPERATION_NAME_KEY_REG) != 0)
2069                 && (strcmp(op, _UAF_OPERATION_NAME_KEY_AUTH) != 0)) {
2070             goto CATCH;
2071         }
2072
2073         uaf_res_temp->fcp = __get_string_from_json_object(uaf_object, _JSON_KEY_FC_PARAMS);
2074
2075         JsonArray *assrt_json_arr = json_object_get_array_member(uaf_object, _JSON_KEY_ASSERTIONS);
2076         CATCH_IF_FAIL(assrt_json_arr != NULL);
2077
2078         int assrt_arr_len = json_array_get_length(assrt_json_arr);
2079         int i = 0;
2080         for (; i < assrt_arr_len; i++) {
2081             JsonObject *assrt_json_obj = json_array_get_object_element(assrt_json_arr, i);
2082             if (assrt_json_obj != NULL) {
2083
2084                 _auth_reg_assertion_t *assrt_data = (_auth_reg_assertion_t*)calloc(1, sizeof(_auth_reg_assertion_t));
2085                 assrt_data->assertion = __get_string_from_json_object(assrt_json_obj, _JSON_KEY_ASSERTION);
2086                 assrt_data->assertion_schm = __get_string_from_json_object(assrt_json_obj, _JSON_KEY_ASSERT_SCHEME);
2087
2088                 uaf_res_temp->assertion_list = g_list_append(uaf_res_temp->assertion_list, assrt_data);
2089
2090             }
2091         }
2092
2093     }
2094
2095     g_object_unref(parser);
2096     _INFO("before _uaf_parser_parse_uaf_response end");
2097     return uaf_res_temp;
2098
2099 CATCH:
2100     if (parser != NULL)
2101         g_object_unref(parser);
2102
2103     if (uaf_res_temp != NULL)
2104         _free_response(uaf_res_temp);
2105
2106     return NULL;
2107 }
2108
2109 static int
2110 __print_string_list(GList *list)
2111 {
2112     RET_IF_FAIL(list != NULL, -1);
2113
2114     GList *list_iter = g_list_first(list);
2115     while (list_iter != NULL) {
2116         char *data = (char*) (list->data);
2117         if (data != NULL)
2118             _INFO("[%s]", data);
2119
2120         list_iter = list_iter->next;
2121     }
2122
2123     return 0;
2124 }
2125
2126 _asm_get_reg_out_t *
2127 _uaf_parser_parser_asm_get_reg_response(const char *get_reg_resp)
2128 {
2129     _INFO("_uaf_parser_parser_asm_get_reg_response start");
2130
2131     RET_IF_FAIL(get_reg_resp != NULL, NULL);
2132
2133     JsonParser *parser = json_parser_new();
2134     RET_IF_FAIL(parser != NULL, NULL);
2135
2136     GError *parser_err = NULL;
2137     gboolean is_parsed = json_parser_load_from_data(parser, get_reg_resp, -1, &parser_err);
2138     RET_IF_FAIL(is_parsed == TRUE, NULL);
2139
2140     _INFO("");
2141
2142     _asm_get_reg_out_t *reg_out = NULL;
2143
2144     JsonNode *root = json_parser_get_root(parser);
2145     CATCH_IF_FAIL(root != NULL);
2146
2147     JsonObject *root_obj = json_node_get_object(root);
2148     CATCH_IF_FAIL(root_obj != NULL);
2149
2150     _INFO("");
2151
2152     /*responseData*/
2153     JsonObject *res_obj = json_object_get_object_member(root_obj, _JSON_KEY_RESP_DATA);
2154     CATCH_IF_FAIL(res_obj != NULL);
2155
2156     /*appRegs*/
2157     JsonArray *app_reg_json_arr = json_object_get_array_member(res_obj, _JSON_KEY_APP_REGS);
2158     CATCH_IF_FAIL(app_reg_json_arr != NULL);
2159
2160     _INFO("");
2161
2162     int app_reg_json_arr_len = json_array_get_length(app_reg_json_arr);
2163     CATCH_IF_FAIL(app_reg_json_arr_len > 0);
2164
2165     reg_out = (_asm_get_reg_out_t*) calloc(1, sizeof(_asm_get_reg_out_t));
2166
2167     int i = 0;
2168     for (; i < app_reg_json_arr_len; i++) {
2169         JsonObject *app_reg_json_obj = json_array_get_object_element(app_reg_json_arr, i);
2170         if (app_reg_json_obj != NULL) {
2171             /*appID*/
2172             const char *app_id = json_object_get_string_member(app_reg_json_obj, _JSON_KEY_APPID);
2173
2174             _INFO("");
2175
2176             /*keyIDs*/
2177             JsonArray *key_id_json_arr = json_object_get_array_member(app_reg_json_obj, _JSON_KEY_KEY_IDS);
2178             GList *key_id_list = __get_string_list_from_json_array(key_id_json_arr);
2179
2180             if (app_id != NULL || key_id_list != NULL) {
2181                 _asm_app_reg_t *app_reg = (_asm_app_reg_t*) calloc(1, sizeof(_asm_app_reg_t));
2182
2183                 if (app_id != NULL) {
2184                     _INFO("app_id = [%s]", app_id);
2185                     app_reg->app_id = strdup(app_id);
2186                 }
2187
2188                 app_reg->key_id_list = key_id_list;
2189                 __print_string_list(key_id_list);
2190
2191                 reg_out->app_reg_list = g_list_append(reg_out->app_reg_list, app_reg);
2192                 _INFO("");
2193
2194             }
2195         }
2196     }
2197
2198     _INFO("");
2199     /*statusCode*/
2200     reg_out->status_code = __get_int_from_json_object(root_obj, _JSON_KEY_STATUS_CODE);
2201
2202 CATCH:
2203     g_object_unref(parser);
2204
2205     _INFO("_uaf_parser_parser_asm_get_reg_response end");
2206     return reg_out;
2207 }
2208
2209 char *
2210 _uaf_composer_compose_get_registrations_request(const char *auth_index)
2211 {
2212     _INFO("_uaf_composer_compose_get_registrations_request");
2213
2214     JsonBuilder *builder = json_builder_new();
2215
2216     json_builder_begin_object(builder);
2217
2218     /*Version : 1.0*/
2219     json_builder_set_member_name(builder, _JSON_KEY_ASM_VERSION);
2220     json_builder_begin_object(builder);
2221     json_builder_set_member_name(builder, _JSON_KEY_MAJOR);
2222     json_builder_add_int_value(builder, _VERSION_MAJOR);
2223     json_builder_set_member_name(builder, _JSON_KEY_MINOR);
2224     json_builder_add_int_value(builder, _VERSION_MINOR);
2225     json_builder_end_object(builder);
2226
2227     /*authenticatorIndex*/
2228     json_builder_set_member_name(builder, _JSON_KEY_AUTH_INDEX);
2229     int auth_index_int = -1;
2230     sscanf(auth_index, "%d", &auth_index_int);
2231     json_builder_add_int_value(builder, auth_index_int);
2232
2233
2234     /*requestType : "GetRegistrations" */
2235     json_builder_set_member_name(builder, _JSON_KEY_REQ_TYPE);
2236     json_builder_add_string_value(builder, _JSON_KEY_GET_REGS);
2237
2238
2239     json_builder_end_object(builder);
2240
2241     JsonNode *root_builder = json_builder_get_root(builder);
2242     JsonGenerator *gen = json_generator_new();
2243     json_generator_set_root(gen, root_builder);
2244
2245     json_node_free(root_builder);
2246     g_object_unref(builder);
2247
2248     gsize len = 0;
2249     char *json = json_generator_to_data(gen, &len);
2250
2251     if (json != NULL)
2252         _INFO("%s", json);
2253
2254     g_object_unref(gen);
2255     return json;
2256 }
2257
2258 int
2259 _convert_asm_status_code_to_uaf_error(int asm_status_code)
2260 {
2261     switch (asm_status_code) {
2262
2263     case _ASM_STATUS_OK:
2264         return FIDO_ERROR_NONE;
2265
2266     case _ASM_STATUS_ERROR:
2267         return FIDO_ERROR_UNKNOWN;
2268
2269     case _ASM_STATUS_ACCESS_DENIED:
2270         return FIDO_ERROR_PERMISSION_DENIED;
2271
2272     case _ASM_STATUS_USER_CANCELLED:
2273         return FIDO_ERROR_USER_CANCELLED;
2274
2275     default:
2276         return FIDO_ERROR_UNKNOWN;
2277     }
2278 }
2279
2280 /*
2281 {
2282     "vendor" : "Samsung Electronics",
2283     "bin_path" : "/usr/bin/fido-asm",
2284     "dbus_info" : "org.tizen.fido_uaf_asm.server",
2285     "dbus_obj_path" : "/org/tizen/fido_uaf_asm/server",
2286     "dbus_interface_name" : "org.tizen.fido_uaf_asm.server.interface",
2287     "dbus_method_name" : "asm_request"
2288 }
2289 */
2290
2291 _fido_asm_proxy_t*
2292 _parse_asm_conf_file(const char *file_name)
2293 {
2294     _INFO("_parse_asm_conf_file");
2295
2296     RET_IF_FAIL(file_name != NULL, NULL);
2297
2298     JsonParser *parser = json_parser_new();
2299
2300     _fido_asm_proxy_t *proxy = NULL;
2301     GError *err = NULL;
2302     gboolean is_parsed = json_parser_load_from_file(parser, file_name, &err);
2303     CATCH_IF_FAIL(is_parsed == TRUE);
2304
2305     JsonNode *root = json_parser_get_root(parser);
2306     CATCH_IF_FAIL(root != NULL);
2307
2308     JsonObject *root_obj = json_node_get_object(root);
2309     CATCH_IF_FAIL(root_obj != NULL);
2310
2311     const char *vendor = json_object_get_string_member(root_obj, _JSON_KEY_VENDOR);
2312     CATCH_IF_FAIL(vendor != NULL);
2313
2314     const char *bin_path = json_object_get_string_member(root_obj, _JSON_KEY_BIN_PATH);
2315     CATCH_IF_FAIL(bin_path != NULL);
2316
2317     const char *dbus_info = json_object_get_string_member(root_obj, _JSON_KEY_DBUS_INFO);
2318     CATCH_IF_FAIL(dbus_info != NULL);
2319
2320     const char *dbus_obj_path = json_object_get_string_member(root_obj, _JSON_KEY_DBUS_OBJ_PATH);
2321     CATCH_IF_FAIL(dbus_obj_path != NULL);
2322
2323     const char *dbus_interface_name = json_object_get_string_member(root_obj, _JSON_KEY_DBUS_INTF_NAME);
2324     CATCH_IF_FAIL(dbus_interface_name != NULL);
2325
2326     const char *dbus_method_name = json_object_get_string_member(root_obj, _JSON_KEY_DBUS_METHOD_NAME);
2327     CATCH_IF_FAIL(dbus_method_name != NULL);
2328
2329     proxy = calloc(1, sizeof(_fido_asm_proxy_t));
2330
2331     proxy->vendor = strdup(vendor);
2332     proxy->bin_path = strdup(bin_path);
2333     proxy->dbus_info = strdup(dbus_info);
2334     proxy->dbus_obj_path = strdup(dbus_obj_path);
2335     proxy->dbus_interface_name = strdup(dbus_interface_name);
2336     proxy->dbus_method_name = strdup(dbus_method_name);
2337
2338 CATCH:
2339     g_object_unref(parser);
2340     return proxy;
2341 }