resource/csdk/security/src/dpairingresource.c

   1 /* *****************************************************************
   2  *
   3  * Copyright 2016 Samsung Electronics All Rights Reserved.
   4  *
   5  *
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *     http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  * *****************************************************************/
  20
  21 #include "iotivity_config.h"
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include "ocstack.h"
  25 #include "logger.h"
  26 #include "oic_malloc.h"
  27 #include "oic_string.h"
  28 #include "cJSON.h"
  29 #include "base64.h"
  30 #include "resourcemanager.h"
  31 #include "dpairingresource.h"
  32 #include "psinterface.h"
  33 #include "utlist.h"
  34 #include "srmresourcestrings.h"
  35 #include "cainterface.h"
  36 #include "doxmresource.h"
  37 #include "pconfresource.h"
  38 #include "credresource.h"
  39 #include "aclresource.h"
  40 #include "srmutility.h"
  41 #include "ocserverrequest.h"
  42 #include "ocpayload.h"
  43 #include "ocpayloadcbor.h"
  44 #include "payload_logging.h"
  45
  46 #ifdef HAVE_STRINGS_H
  47 #include <strings.h>
  48 #endif
  49
  50 #ifdef __WITH_DTLS__
  51 #include "global.h"
  52 #endif
  53
  54 #define TAG  "OIC_SRM_DPAIRING"
  55
  56 /** Default cbor payload size. This value is increased in case of CborErrorOutOfMemory.
  57  * The value of payload size is increased until reaching belox max cbor size. */
  58 static const uint16_t CBOR_SIZE = 1024;
  59
  60 /** Max cbor size payload. */
  61 static const uint16_t CBOR_MAX_SIZE = 4400;
  62
  63 /** DOXM Map size - Number of mandatory items. */
  64 static const uint8_t DPAIR_MAP_SIZE = 3;
  65
  66 static OicSecDpairing_t     *gDpair = NULL;
  67 static OCResourceHandle   gDpairHandle = NULL;
  68 static OicSecDpairing_t      gDefaultDpair =
  69 {
  70     PRM_NOT_ALLOWED,       /* OicSecPrm_t spm */
  71     {.id = {0}},                   /* OicUuid_t pdeviceID */
  72     {.id = {0}},                   /* OicUuid_t rowner */
  73 };
  74
  75 void DeleteDpairingBinData(OicSecDpairing_t* dpair)
  76 {
  77     if (dpair)
  78     {
  79         //Clean dpairing itself
  80         OICFree(dpair);
  81     }
  82 }
  83
  84 /**
  85  * Get the default value.
  86  * @retval  the gDefaultDpair pointer;
  87  */
  88 static OicSecDpairing_t* GetDpairingDefault()
  89 {
  90     OIC_LOG (DEBUG, TAG, "GetDpairingDefault");
  91
  92     return &gDefaultDpair;
  93 }
  94
  95 /**
  96  * This method is used by SRM to retrieve Dpairing resource data..
  97  */
  98 void SetDpairingResourceOwner(OicUuid_t *rowner)
  99 {
 100     OIC_LOG (DEBUG, TAG, "SetDpairingResourceOwner");
 101     if (gDpair)
 102     {
 103         memcpy(&gDpair->rownerID, rowner, sizeof(OicUuid_t));
 104     }
 105 }
 106
 107 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
 108 /**
 109  * Function to save PairingPSK.
 110  *
 111  * @param[in] endpoint   current endpoint.
 112  * @param[in] peerDevID   peer device indentitiy.
 113  * @param[in] isPairingServer   indicate if it generates PairingPSK for server or client.
 114  *
 115  * @return  OC_STACK_OK on success
 116  */
 117 OCStackResult SavePairingPSK(OCDevAddr *endpoint,
 118             OicUuid_t *peerDevID, OicUuid_t *owner, bool isPairingServer)
 119 {
 120     OIC_LOG(DEBUG, TAG, "IN SavePairingPSK");
 121
 122     if(NULL == endpoint || NULL == peerDevID || NULL == owner)
 123     {
 124         OIC_LOG_V(ERROR, TAG, "Invalid Input parameters in [%s]\n", __FUNCTION__);
 125         return OC_STACK_INVALID_PARAM;
 126     }
 127
 128     OCStackResult res = OC_STACK_ERROR;
 129
 130     OicUuid_t ptDeviceID = {.id={0}};
 131     if (OC_STACK_OK != GetDoxmDeviceID(&ptDeviceID))
 132     {
 133         OIC_LOG(ERROR, TAG, "Error while retrieving provisioning tool's device ID");
 134         return res;
 135     }
 136
 137     uint8_t pairingPSK[OWNER_PSK_LENGTH_128] = {0};
 138     OicSecKey_t pairingKey = {pairingPSK, OWNER_PSK_LENGTH_128, OIC_ENCODING_RAW};
 139
 140     //Generating PairingPSK using OwnerPSK scheme
 141     CAResult_t pskRet = CAGenerateOwnerPSK((const CAEndpoint_t *)endpoint,
 142             (uint8_t *)OIC_RSRC_TYPE_SEC_DPAIRING,
 143             strlen(OIC_RSRC_TYPE_SEC_DPAIRING),
 144             (isPairingServer ? ptDeviceID.id : peerDevID->id), sizeof(OicUuid_t), // server
 145             (isPairingServer ? peerDevID->id : ptDeviceID.id), sizeof(OicUuid_t), // client
 146             pairingPSK, OWNER_PSK_LENGTH_128);
 147
 148     if (CA_STATUS_OK == pskRet)
 149     {
 150         OIC_LOG(DEBUG, TAG, "pairingPSK dump:\n");
 151         OIC_LOG_BUFFER(DEBUG, TAG, pairingPSK, OWNER_PSK_LENGTH_128);
 152         //Generating new credential for direct-pairing client
 153
 154         OicSecCred_t *cred = GenerateCredential(peerDevID,
 155                 SYMMETRIC_PAIR_WISE_KEY, NULL,
 156                 &pairingKey, owner, NULL);
 157         OICClearMemory(pairingPSK, sizeof(pairingPSK));
 158         VERIFY_NON_NULL(TAG, cred, ERROR);
 159
 160         res = AddCredential(cred);
 161         if(res != OC_STACK_OK)
 162         {
 163             DeleteCredList(cred);
 164             return res;
 165         }
 166     }
 167     else
 168     {
 169         OIC_LOG(ERROR, TAG, "CAGenerateOwnerPSK failed");
 170     }
 171
 172     OIC_LOG(DEBUG, TAG, "OUT SavePairingPSK");
 173 exit:
 174     return res;
 175 }
 176 #endif // __WITH_DTLS__ or __WITH_TLS__
 177
 178 OCStackResult DpairingToCBORPayload(const OicSecDpairing_t *dpair, uint8_t **payload, size_t *size)
 179 {
 180     if (NULL == dpair || NULL == payload || NULL != *payload || NULL == size)
 181     {
 182         return OC_STACK_INVALID_PARAM;
 183     }
 184
 185     size_t cborLen = *size;
 186     if (0 == cborLen)
 187     {
 188         cborLen = CBOR_SIZE;
 189     }
 190
 191     *payload = NULL;
 192     *size = 0;
 193
 194     OCStackResult ret = OC_STACK_ERROR;
 195
 196     CborEncoder encoder;
 197     CborEncoder dpairMap;
 198
 199     int64_t cborEncoderResult = CborNoError;
 200     uint8_t mapSize = DPAIR_MAP_SIZE;
 201
 202     uint8_t *outPayload = (uint8_t *)OICCalloc(1, cborLen);
 203     VERIFY_NON_NULL(TAG, outPayload, ERROR);
 204     cbor_encoder_init(&encoder, outPayload, cborLen, 0);
 205
 206     cborEncoderResult = cbor_encoder_create_map(&encoder, &dpairMap, mapSize);
 207     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Creating DPAIRING Map");
 208
 209     //spm -- Mandatory
 210     cborEncoderResult = cbor_encode_text_string(&dpairMap, OIC_JSON_SPM_NAME,
 211         strlen(OIC_JSON_SPM_NAME));
 212     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SPM name tag");
 213     cborEncoderResult = cbor_encode_int(&dpairMap, dpair->spm);
 214     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SPM value");
 215
 216     //PDEVICEID -- Mandatory
 217     cborEncoderResult = cbor_encode_text_string(&dpairMap, OIC_JSON_PDEVICE_ID_NAME,
 218         strlen(OIC_JSON_PDEVICE_ID_NAME));
 219     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding PDeviceID tag");
 220     {
 221         char *deviceId = NULL;
 222         ret = ConvertUuidToStr(&dpair->pdeviceID, &deviceId);
 223         VERIFY_SUCCESS(TAG, ret == OC_STACK_OK, ERROR);
 224         cborEncoderResult = cbor_encode_text_string(&dpairMap, deviceId, strlen(deviceId));
 225         VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to encode PDeviceID value");
 226         OICFree(deviceId);
 227     }
 228
 229     //ROWNER -- Mandatory
 230     {
 231         char *rowner = NULL;
 232         cborEncoderResult = cbor_encode_text_string(&dpairMap, OIC_JSON_ROWNERID_NAME,
 233             strlen(OIC_JSON_ROWNERID_NAME));
 234         VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ROWNER tag");
 235         ret = ConvertUuidToStr(&dpair->rownerID, &rowner);
 236         VERIFY_SUCCESS(TAG, ret == OC_STACK_OK, ERROR);
 237         cborEncoderResult = cbor_encode_text_string(&dpairMap, rowner, strlen(rowner));
 238         VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Rowner ID value");
 239         OICFree(rowner);
 240     }
 241
 242     cborEncoderResult = cbor_encoder_close_container(&encoder, &dpairMap);
 243     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to close dpairMap");
 244
 245      if (CborNoError == cborEncoderResult)
 246     {
 247         *size = cbor_encoder_get_buffer_size(&encoder, outPayload);
 248         *payload = outPayload;
 249         ret = OC_STACK_OK;
 250     }
 251
 252 exit:
 253     if ((CborErrorOutOfMemory == cborEncoderResult) && (cborLen < CBOR_MAX_SIZE))
 254     {
 255        // reallocate and try again!
 256        OICFree(outPayload);
 257        // Since the allocated initial memory failed, double the memory.
 258        cborLen += cbor_encoder_get_buffer_size(&encoder, encoder.end);
 259        cborEncoderResult = CborNoError;
 260        ret = DpairingToCBORPayload(dpair, payload, &cborLen);
 261        *size = cborLen;
 262     }
 263
 264     if ((CborNoError != cborEncoderResult) || (OC_STACK_OK != ret))
 265     {
 266        OICFree(outPayload);
 267        outPayload = NULL;
 268        *payload = NULL;
 269        *size = 0;
 270        ret = OC_STACK_ERROR;
 271     }
 272
 273     return ret;
 274 }
 275
 276 OCStackResult CBORPayloadToDpair(const uint8_t *cborPayload, size_t size,
 277                                 OicSecDpairing_t **secDpair)
 278 {
 279     if (NULL == cborPayload || NULL == secDpair || NULL != *secDpair || 0 == size)
 280     {
 281         return OC_STACK_INVALID_PARAM;
 282     }
 283
 284     OCStackResult ret = OC_STACK_ERROR;
 285     *secDpair = NULL;
 286
 287     CborValue dpairCbor = { .parser = NULL };
 288     CborParser parser = { .end = NULL };
 289     CborError cborFindResult = CborNoError;
 290
 291     cbor_parser_init(cborPayload, size, 0, &parser, &dpairCbor);
 292     CborValue dpairMap = { .parser = NULL };
 293     OicSecDpairing_t *dpair = NULL;
 294     cborFindResult = cbor_value_enter_container(&dpairCbor, &dpairMap);
 295     VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Entering DPairing Map");
 296
 297     dpair = (OicSecDpairing_t *)OICCalloc(1, sizeof(*dpair));
 298     VERIFY_NON_NULL(TAG, dpair, ERROR);
 299
 300     while (cbor_value_is_valid(&dpairMap) && cbor_value_is_text_string(&dpairMap))
 301     {
 302         char *name = NULL;
 303         size_t len = 0;
 304         CborType type = CborInvalidType;
 305         cborFindResult = cbor_value_dup_text_string(&dpairMap, &name, &len, NULL);
 306         VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding tag name");
 307         cborFindResult = cbor_value_advance(&dpairMap);
 308         VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing a value in DPair map");
 309
 310         type = cbor_value_get_type(&dpairMap);
 311         if (0 == strcmp(OIC_JSON_SPM_NAME, name) && cbor_value_is_integer(&dpairMap))
 312         {
 313             int spm;
 314
 315             cborFindResult = cbor_value_get_int(&dpairMap, &spm);
 316             VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding SPM Value");
 317             dpair->spm = (OicSecPrm_t)spm;
 318         }
 319
 320         if (0 == strcmp(OIC_JSON_PDEVICE_ID_NAME, name))
 321         {
 322             char *id = NULL;
 323             cborFindResult = cbor_value_dup_text_string(&dpairMap, &id, &len, NULL);
 324             VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding PDeviceID value");
 325             ret = ConvertStrToUuid(id, &dpair->pdeviceID);
 326             VERIFY_SUCCESS(TAG, ret == OC_STACK_OK, ERROR);
 327             OICFree(id);
 328         }
 329
 330         if (0 == strcmp(OIC_JSON_ROWNERID_NAME, name))
 331         {
 332             char *id = NULL;
 333             cborFindResult = cbor_value_dup_text_string(&dpairMap, &id, &len, NULL);
 334             VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding RownerID value");
 335             ret = ConvertStrToUuid(id, &dpair->rownerID);
 336             VERIFY_SUCCESS(TAG, ret == OC_STACK_OK, ERROR);
 337             OICFree(id);
 338         }
 339
 340         if (CborMapType != type && cbor_value_is_valid(&dpairMap))
 341         {
 342             cborFindResult = cbor_value_advance(&dpairMap);
 343             VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing the Dpair Map");
 344         }
 345         OICFree(name);
 346     }
 347
 348     *secDpair = dpair;
 349     ret = OC_STACK_OK;
 350
 351 exit:
 352     if (CborNoError != cborFindResult)
 353     {
 354         OIC_LOG (ERROR, TAG, "CBORPayloadToDoxm failed");
 355         DeleteDpairingBinData(dpair);
 356         dpair = NULL;
 357         *secDpair = NULL;
 358         ret = OC_STACK_ERROR;
 359     }
 360     return ret;
 361 }
 362 /**
 363  * Function to handle the handshake result in Direct-Pairing.
 364  * This function will be invoked after DTLS handshake
 365  * @param   endPoint  [IN] The remote endpoint.
 366  * @param   errorInfo [IN] Error information from the endpoint.
 367  * @return  NONE
 368  */
 369 void DPairingDTLSHandshakeCB(const CAEndpoint_t *endpoint, const CAErrorInfo_t *info)
 370 {
 371     OIC_LOG_V(INFO, TAG, "IN DPairingDTLSHandshakeCB");
 372
 373     if(gDpair && endpoint && info)
 374     {
 375         OIC_LOG_V(INFO, TAG, "Received status from remote device(%s:%d) : %d",
 376                  endpoint->addr, endpoint->port, info->result);
 377
 378         if(CA_STATUS_OK == info->result)
 379         {
 380             OIC_LOG(INFO, TAG, "DPairingDTLSHandshakeCB - Connection success.");
 381         }
 382         else if(CA_DTLS_AUTHENTICATION_FAILURE == info->result)
 383         {
 384             OIC_LOG(INFO, TAG, "DPairingDTLSHandshakeCB - Authentication failed");
 385
 386         }
 387
 388 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
 389         CAregisterSslHandshakeCallback(NULL);
 390 #endif // __WITH_DTLS__ or __WITH_TLS__
 391
 392         // delete temporary key
 393         RemoveCredential(&gDpair->pdeviceID);
 394     }
 395
 396     OIC_LOG_V(INFO, TAG, "OUT DPairingDTLSHandshakeCB");
 397 }
 398
 399 static OCEntityHandlerResult HandleDpairingPostRequest (const OCEntityHandlerRequest * ehRequest)
 400 {
 401     OIC_LOG (DEBUG, TAG, "Dpairing EntityHandle  processing POST request");
 402     OCEntityHandlerResult ehRet = OC_EH_ERROR;
 403     OicSecDpairing_t* newDpair = NULL;
 404     OCStackResult res = OC_STACK_OK;
 405
 406     const OicSecPconf_t *pconf = GetPconfResourceData();
 407     if (true == pconf->edp)
 408     {
 409         uint8_t *payload = ((OCSecurityPayload*)ehRequest->payload)->securityData;
 410         size_t size = ((OCSecurityPayload*)ehRequest->payload)->payloadSize;
 411         if (payload)
 412         {
 413             res = CBORPayloadToDpair(payload, size, &newDpair);
 414         }
 415     }
 416     else
 417     {
 418         OIC_LOG (DEBUG, TAG, "EDP == false : Direct-Pairing Disabled");
 419         ehRet = OC_EH_ERROR;
 420     }
 421
 422     if (OC_STACK_OK == res && newDpair && false == IsPairedDevice(&newDpair->pdeviceID))
 423     {
 424         // Check if valid Post request
 425         bool prmMached = false;
 426         for (size_t i=0; i<pconf->prmLen; i++)
 427         {
 428             if (newDpair->spm == pconf->prm[i])
 429             {
 430                 prmMached = true;
 431                 break;
 432             }
 433         }
 434         OIC_LOG_V(DEBUG, TAG, "Parsed spm is %s", prmMached ? "valid" :
 435                 "invalid, send error response");
 436
 437         // Update local Dpairing with new Dpairing & prepare dtls session
 438         if (prmMached && '\0' != (char)newDpair->pdeviceID.id[0])
 439         {
 440             if(!gDpair)
 441             {
 442                 gDpair = GetDpairingDefault();
 443             }
 444             gDpair->spm = newDpair->spm;
 445             memcpy(&gDpair->pdeviceID, &newDpair->pdeviceID, sizeof(OicUuid_t));
 446             memcpy(&gDpair->rownerID, &pconf->rownerID, sizeof(OicUuid_t));
 447
 448 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
 449             // Add temporary psk
 450             OCStackResult res;
 451             OicUuid_t subjectId = {.id={0}};
 452             res = AddTmpPskWithPIN(&gDpair->pdeviceID,
 453                            SYMMETRIC_PAIR_WISE_KEY,
 454                            (char*)pconf->pin.val, DP_PIN_LENGTH,
 455                            &gDpair->rownerID, &subjectId);
 456             if(res != OC_STACK_OK ||
 457                     memcmp(&gDpair->pdeviceID, &subjectId, sizeof(OicUuid_t)))
 458             {
 459                 OIC_LOG_V(ERROR, TAG, "Failed to save the temporal PSK : %d", res);
 460                 goto exit;
 461             }
 462
 463             // Prepare to establish a secure channel with Pin-based PSK cipher suite
 464             if (CA_STATUS_OK != CAEnableAnonECDHCipherSuite(false) ||
 465                 CA_STATUS_OK != CASelectCipherSuite(TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA_256, CA_ADAPTER_IP))
 466             {
 467                 OIC_LOG_V(ERROR, TAG, "Failed to select TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA_256");
 468                 goto exit;
 469             }
 470
 471             if(CA_STATUS_OK != CAregisterSslHandshakeCallback(DPairingDTLSHandshakeCB))
 472             {
 473                 OIC_LOG(WARNING, TAG, "DirectPairingHandler : Failed to register"
 474                         " DTLS handshake callback.");
 475                 goto exit;
 476             }
 477 #endif // __WITH_DTLS__ or __WITH_TLS__
 478
 479             // should be lock /oic/sec/dpairing resource if Direct-Pairing starts normally ?
 480             OIC_LOG (DEBUG, TAG, "/oic/sec/dpairing resource created");
 481
 482             ehRet = OC_EH_RESOURCE_CREATED;
 483         }
 484         else
 485         {
 486             OIC_LOG(ERROR, TAG, "Error in request check");
 487         }
 488     }
 489
 490
 491 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
 492 exit:
 493 #endif // __WITH_DTLS__ or __WITH_TLS__
 494
 495     // Send payload to request originator
 496     if(OC_STACK_OK != SendSRMResponse(ehRequest, ehRet, NULL, 0))
 497     {
 498         ehRet = OC_EH_ERROR;
 499         OIC_LOG (ERROR, TAG, "SendSRMResponse failed in HandleDpairingPostRequest");
 500     }
 501
 502     if (OC_EH_ERROR == ehRet && gDpair)
 503     {
 504         RemoveCredential(&gDpair->pdeviceID);
 505         gDpair = NULL;
 506     }
 507
 508     DeleteDpairingBinData(newDpair);
 509     OIC_LOG_V (DEBUG, TAG, "%s RetVal %d", __func__ , ehRet);
 510     return ehRet;
 511 }
 512
 513 static OCEntityHandlerResult HandleDpairingPutRequest (const OCEntityHandlerRequest * ehRequest)
 514 {
 515     OIC_LOG (DEBUG, TAG, "Dpairing EntityHandle  processing PUT request (Comfirmation)");
 516
 517     OCEntityHandlerResult ehRet = OC_EH_ERROR;
 518     OicSecDpairing_t* newDpair = NULL;
 519     OCStackResult res = OC_STACK_OK;
 520
 521     const OicSecPconf_t *pconf = GetPconfResourceData();
 522     if (true == pconf->edp)
 523     {
 524         uint8_t *payload = ((OCSecurityPayload*)ehRequest->payload)->securityData;
 525         size_t size = ((OCSecurityPayload*)ehRequest->payload)->payloadSize;
 526         if (payload)
 527         {
 528             res = CBORPayloadToDpair(payload, size, &newDpair);
 529         }
 530
 531     }
 532     else
 533     {
 534         OIC_LOG (DEBUG, TAG, "EDP == false : Direct-Pairing Disabled");
 535         ehRet = OC_EH_ERROR;
 536     }
 537
 538
 539     if ((OC_STACK_OK == res) && gDpair && newDpair)
 540     {
 541         OIC_LOG(DEBUG, TAG, "Received direct-pairing finalization request");
 542
 543         // Check if valid Put request
 544         VERIFY_SUCCESS(TAG, PRM_NOT_ALLOWED == newDpair->spm, ERROR);
 545
 546         const OicSecPconf_t *pconf = GetPconfResourceData();
 547         VERIFY_NON_NULL(TAG, pconf, ERROR);
 548
 549 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
 550         OCServerRequest *request = GetServerRequestUsingHandle(ehRequest->requestHandle);
 551         VERIFY_SUCCESS(TAG, (request->devAddr.flags | OC_FLAG_SECURE), ERROR);
 552
 553         //Generate new credential
 554         OIC_LOG_V(INFO, TAG, "SavePairingPSK for %s(%d)", request->devAddr.addr,
 555                 request->devAddr.port);
 556         OCStackResult res = SavePairingPSK(&request->devAddr, &newDpair->pdeviceID,
 557                 (OicUuid_t *)&pconf->rownerID, true);
 558         VERIFY_SUCCESS(TAG, OC_STACK_OK == res, ERROR);
 559 #endif // __WITH_DTLS__ or __WITH_TLS__
 560
 561         //Generate new acl
 562         OicSecPdAcl_t *pdAcl;
 563         LL_FOREACH(pconf->pdacls, pdAcl)
 564         {
 565             OicSecAcl_t* acl = (OicSecAcl_t*)OICCalloc(1, sizeof(OicSecAcl_t));
 566             VERIFY_NON_NULL(TAG, acl, ERROR);
 567
 568             OicSecAce_t* ace = (OicSecAce_t*)OICCalloc(1, sizeof(OicSecAce_t));
 569             VERIFY_NON_NULL(TAG, ace, ERROR);
 570
 571             LL_APPEND(acl->aces, ace);
 572
 573             memcpy(&ace->subjectuuid, &gDpair->pdeviceID, sizeof(OicUuid_t));
 574
 575             for(size_t i = 0; i < pdAcl->resourcesLen; i++)
 576             {
 577                 OicSecRsrc_t* rsrc = (OicSecRsrc_t*)OICCalloc(1, sizeof(OicSecRsrc_t));
 578                 VERIFY_NON_NULL(TAG, rsrc, ERROR);
 579                 LL_APPEND(ace->resources, rsrc);
 580
 581                 //href
 582                 rsrc->href = OICStrdup(pdAcl->resources[i]);
 583
 584                 // TODO: Append 'if' and 'rt' as workaround
 585                 // if
 586                 rsrc->interfaceLen = 1;
 587                 rsrc->interfaces = (char**)OICCalloc(rsrc->interfaceLen, sizeof(char));
 588                 VERIFY_NON_NULL(TAG, (rsrc->interfaces), ERROR);
 589                 rsrc->interfaces[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
 590                 VERIFY_NON_NULL(TAG, (rsrc->interfaces[0]), ERROR);
 591
 592                 //rt
 593                 rsrc->typeLen = 1;
 594                 rsrc->types = (char**)OICCalloc(rsrc->typeLen, sizeof(char));
 595                 VERIFY_NON_NULL(TAG, (rsrc->types), ERROR);
 596                 rsrc->types[0] = OICStrdup("oic.core");
 597                 VERIFY_NON_NULL(TAG, (rsrc->types[0]), ERROR);
 598             }
 599
 600             ace->permission = pdAcl->permission;
 601
 602             //Copy the validity
 603             if(pdAcl->periods || pdAcl->recurrences)
 604             {
 605                 OicSecValidity_t* validity = (OicSecValidity_t*)OICCalloc(1, sizeof(OicSecValidity_t));
 606                 VERIFY_NON_NULL(TAG, validity, ERROR);
 607
 608                 if(pdAcl->periods && pdAcl->periods[0])
 609                 {
 610                     size_t periodLen = strlen(pdAcl->periods[0]) + 1;
 611                     validity->period = (char*)OICMalloc(periodLen * sizeof(char));
 612                     VERIFY_NON_NULL(TAG, (validity->period), ERROR);
 613                     OICStrcpy(validity->period, periodLen, pdAcl->periods[0]);
 614                 }
 615
 616                 if(pdAcl->recurrences && 0 < pdAcl->prdRecrLen)
 617                 {
 618                     validity->recurrenceLen = pdAcl->prdRecrLen;
 619                     validity->recurrences = (char**)OICMalloc(sizeof(char*) * pdAcl->prdRecrLen);
 620                     VERIFY_NON_NULL(TAG, (validity->recurrences), ERROR);
 621
 622                     for(size_t i = 0; i < pdAcl->prdRecrLen; i++)
 623                     {
 624                         size_t recurrenceLen = strlen(pdAcl->recurrences[i]) + 1;
 625                         validity->recurrences[i] = (char*)OICMalloc(recurrenceLen  * sizeof(char));
 626                         VERIFY_NON_NULL(TAG, (validity->recurrences[i]), ERROR);
 627
 628                         OICStrcpy(validity->recurrences[i], recurrenceLen, pdAcl->recurrences[i]);
 629                     }
 630                 }
 631
 632                 LL_APPEND(ace->validities, validity);
 633             }
 634
 635             size_t size = 0;
 636             uint8_t *payload = NULL;
 637             if (OC_STACK_OK == AclToCBORPayload(acl, &payload, &size))
 638             {
 639                 AppendACL(payload, size);
 640                 OICFree(payload);
 641             }
 642             DeleteACLList(acl);
 643         }
 644
 645         //update pconf device list
 646         AddPairedDevice(&newDpair->pdeviceID);
 647
 648         //Initialize dpairing resource
 649         gDpair = NULL;
 650
 651         OIC_LOG (DEBUG, TAG, "/oic/sec/dpairing resource updated,"
 652                 "direct-pairing finalization success");
 653         ehRet = OC_EH_OK;
 654     }
 655
 656 exit:
 657
 658     //Send payload to request originator
 659     if(OC_STACK_OK != SendSRMResponse(ehRequest, ehRet, NULL, 0))
 660     {
 661         ehRet = OC_EH_ERROR;
 662         OIC_LOG (ERROR, TAG, "SendSRMResponse failed in HandleDpairingPutRequest");
 663     }
 664
 665     DeleteDpairingBinData(newDpair);
 666     OIC_LOG_V (DEBUG, TAG, "%s RetVal %d", __func__ , ehRet);
 667     return ehRet;
 668 }
 669 /*
 670  * This internal method is the entity handler for Dpairing resources and
 671  * will handle REST request (GET/POST) for them.
 672  */
 673 OCEntityHandlerResult DpairingEntityHandler (OCEntityHandlerFlag flag,
 674                                         OCEntityHandlerRequest * ehRequest,
 675                                         void* callbackParameter)
 676 {
 677     OIC_LOG(DEBUG, TAG, "Received request DpairingEntityHandler");
 678     (void)callbackParameter;
 679     OCEntityHandlerResult ehRet = OC_EH_ERROR;
 680
 681     if (!ehRequest)
 682     {
 683         return ehRet;
 684     }
 685
 686     if (flag & OC_REQUEST_FLAG)
 687     {
 688         OIC_LOG (DEBUG, TAG, "Flag includes OC_REQUEST_FLAG");
 689         switch (ehRequest->method)
 690         {
 691             case OC_REST_GET:
 692                 break;
 693
 694             case OC_REST_POST:
 695                 ehRet = HandleDpairingPostRequest(ehRequest);
 696                 break;
 697
 698             case OC_REST_PUT:
 699                 ehRet = HandleDpairingPutRequest(ehRequest);
 700                 break;
 701
 702             case OC_REST_DELETE:
 703                 break;
 704
 705             default:
 706                 ehRet = OC_EH_ERROR;
 707                 SendSRMResponse(ehRequest, ehRet, NULL, 0);
 708         }
 709     }
 710
 711     return ehRet;
 712 }
 713
 714 /*
 715  * This internal method is used to create '/oic/sec/dpairing' resource.
 716  */
 717 OCStackResult CreateDpairingResource()
 718 {
 719     OCStackResult ret;
 720
 721     ret = OCCreateResource(&gDpairHandle,
 722                            OIC_RSRC_TYPE_SEC_DPAIRING,
 723                            OC_RSRVD_INTERFACE_DEFAULT,
 724                            OIC_RSRC_DPAIRING_URI,
 725                            DpairingEntityHandler,
 726                            NULL,
 727                            OC_SECURE | OC_EXPLICIT_DISCOVERABLE);
 728
 729     if (OC_STACK_OK != ret)
 730     {
 731         OIC_LOG (ERROR, TAG, "Unable to instantiate Dpairing resource");
 732         DeInitDpairingResource();
 733     }
 734     return ret;
 735 }
 736
 737 /**
 738  * Initialize Dpairing resource by loading data from persistent storage.
 739  *
 740  * @retval  OC_STACK_OK for Success, otherwise some error value
 741  */
 742 OCStackResult InitDpairingResource()
 743 {
 744     OCStackResult ret = OC_STACK_ERROR;
 745
 746     // Instantiate 'oic.sec.dpairing'
 747     ret = CreateDpairingResource();
 748     if (OC_STACK_OK != ret)
 749     {
 750         DeInitDpairingResource();
 751     }
 752     return ret;
 753 }
 754
 755 /**
 756  * Perform cleanup for Dpairing resources.
 757  *
 758  * @return
 759  * OC_STACK_OK    - no error
 760  * OC_STACK_ERROR - stack process error
 761  *
 762  */
 763 OCStackResult DeInitDpairingResource()
 764 {
 765     OCStackResult ret = OCDeleteResource(gDpairHandle);
 766     gDpair = NULL;
 767
 768     if(OC_STACK_OK == ret)
 769     {
 770         return OC_STACK_OK;
 771     }
 772     else
 773     {
 774         return OC_STACK_ERROR;
 775     }
 776 }
 777
 778 OCStackResult SetDpairingRownerId(const OicUuid_t* newROwner)
 779 {
 780     OCStackResult ret = OC_STACK_ERROR;
 781     uint8_t *cborPayload = NULL;
 782     size_t size = 0;
 783     OicUuid_t prevId = {.id={0}};
 784
 785     if(NULL == newROwner)
 786     {
 787         ret = OC_STACK_INVALID_PARAM;
 788     }
 789     if(NULL == gDpair)
 790     {
 791         ret = OC_STACK_NO_RESOURCE;
 792     }
 793
 794     if(newROwner && gDpair)
 795     {
 796         memcpy(prevId.id, gDpair->rownerID.id, sizeof(prevId.id));
 797         memcpy(gDpair->rownerID.id, newROwner->id, sizeof(newROwner->id));
 798
 799         ret = DpairingToCBORPayload(gDpair, &cborPayload, &size);
 800         VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
 801
 802         ret = UpdateSecureResourceInPS(OIC_JSON_DPAIRING_NAME, cborPayload, size);
 803         VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
 804
 805         OICFree(cborPayload);
 806     }
 807
 808     return ret;
 809
 810 exit:
 811     OICFree(cborPayload);
 812     memcpy(gDpair->rownerID.id, prevId.id, sizeof(prevId.id));
 813     return ret;
 814 }
 815
 816 OCStackResult GetDpairingRownerId(OicUuid_t *rowneruuid)
 817 {
 818     OCStackResult retVal = OC_STACK_ERROR;
 819     if (gDpair)
 820     {
 821         *rowneruuid = gDpair->rownerID;
 822         retVal = OC_STACK_OK;
 823     }
 824     return retVal;
 825 }