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