test/src/tc/pm/gtest/csdk/src/helper/PMCsdkCertHelper.cpp

   1 /******************************************************************
   2  *
   3  * Copyright 2017 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 "PMCsdkCertHelper.h"
  22 #include "PMCsdkCallbackHelper.h"
  23 #include "PMCsdkUtilityHelper.h"
  24
  25 int PMCsdkCertHelper::g_OwnDevCount = 0;
  26 int PMCsdkCertHelper::g_UnownDevCount = 0;
  27 int PMCsdkCertHelper::g_motPMDevCount = 0;
  28 char* PMCsdkCertHelper::g_csrVal = NULL;
  29 OCPersistentStorage PMCsdkCertHelper::pstStr =
  30 { 0, 0, 0, 0, 0 };
  31 ByteArray s_trustCertChainArray =
  32 { 0, 0 };
  33
  34 FILE* PMCsdkCertHelper::fopenProvManager(const char* path, const char* mode)
  35 {
  36     OC_UNUSED(path);
  37     return fopen(SVR_DB_FILE_NAME, mode);
  38 }
  39
  40 int PMCsdkCertHelper::waitCallbackRet(void)
  41 {
  42     __FUNC_IN__
  43
  44     for (int i = 0; CALLBACK_TIMEOUT > i; ++i)
  45     {
  46         IOTIVITYTEST_LOG(DEBUG, "PMCsdkCertHelper::waitCallbackRet Loop = %d", i);
  47
  48         if (true == PMCsdkCallbackHelper::s_CBInvoked)
  49         {
  50             return CALLBACK_INVOKED;
  51         }
  52
  53         CommonUtil::waitInSecond(DELAY_SHORT);
  54
  55         if (OC_STACK_OK != OCProcess())
  56         {
  57             IOTIVITYTEST_LOG(ERROR, "OCStack process error");
  58             return CALLBACK_NOT_INVOKED;
  59         }
  60     }
  61
  62     __FUNC_OUT__
  63     return CALLBACK_NOT_INVOKED;
  64 }
  65
  66
  67
  68 void PMCsdkCertHelper::trustCertChainChangeCB(void *ctx, uint16_t credId, uint8_t *trustCertChain,
  69         size_t chainSize)
  70 {
  71     __FUNC_IN__
  72
  73     IOTIVITYTEST_LOG(INFO, "Provision Cert SUCCEEDED - ctx: %s", (char* ) ctx);
  74
  75     IOTIVITYTEST_LOG(INFO, "CRED ID : %d", credId);
  76
  77     OIC_LOG_BUFFER(DEBUG, "Cert Cb", trustCertChain, chainSize);
  78
  79     PMCsdkCallbackHelper::s_CBInvoked= true;
  80
  81     __FUNC_OUT__
  82 }
  83
  84 void PMCsdkCertHelper::getCsrForCertProvCB(void* ctx, size_t nOfRes, OCPMGetCsrResult_t* arr,
  85 bool hasError)
  86 {
  87     if (!hasError)
  88     {
  89         if (nOfRes != 1)
  90         {
  91             IOTIVITYTEST_LOG(ERROR, "getCsrForCertProvCB FAILED - ctx: %s", (char* )ctx);
  92         }
  93
  94         if (arr[0].encoding == OIC_ENCODING_DER)
  95         {
  96             OCStackResult res = OCConvertDerCSRToPem((char*) arr[0].csr, arr[0].csrLen, &g_csrVal);
  97             if (res != OC_STACK_OK)
  98             {
  99                 IOTIVITYTEST_LOG(ERROR,
 100                         "getCsrForCertProvCB FAILED (CSR re-encoding failed) - error: %d, ctx: %s",
 101                         res, (char* )ctx);
 102             }
 103             PMCsdkCallbackHelper::s_CBInvoked= true;
 104         }
 105         else if (arr[0].encoding == OIC_ENCODING_PEM)
 106         {
 107             g_csrVal = (char*) OICCalloc(1, arr[0].csrLen);
 108             if (g_csrVal == NULL)
 109             {
 110                 IOTIVITYTEST_LOG(ERROR, "getCsrForCertProvCB FAILED (memory allocation) - ctx: %s",
 111                         (char* )ctx);
 112             }
 113
 114             memcpy(g_csrVal, arr[0].csr, arr[0].csrLen);
 115
 116             IOTIVITYTEST_LOG(INFO, "getCsrForCertProvCB success");
 117             PMCsdkCallbackHelper::s_CBInvoked= true;
 118         }
 119         else
 120         {
 121             IOTIVITYTEST_LOG(ERROR, "getCsrForCertProvCB FAILED (unknown encoding) - ctx: %s",
 122                     (char* )ctx);
 123         }
 124     }
 125     else
 126     {
 127         IOTIVITYTEST_LOG(ERROR, "getCsrForCertProvCB FAILED - ctx: %s", (char* )ctx);
 128     }
 129
 130 }
 131
 132 // CAPI for Provisioning Manager
 133
 134 PMCsdkCertHelper::PMCsdkCertHelper()
 135 {
 136     IOTIVITYTEST_LOG(DEBUG, "[PMHelper] Constructor");
 137 }
 138
 139 bool PMCsdkCertHelper::initProvisionClient(int clientOTMType, char* chDBPath)
 140 {
 141     __FUNC_IN__
 142
 143     pstStr.open = PMCsdkCertHelper::fopenProvManager;
 144     pstStr.read = fread;
 145     pstStr.write = fwrite;
 146     pstStr.close = fclose;
 147     pstStr.unlink = unlink;
 148
 149     if (OC_STACK_OK != OCRegisterPersistentStorageHandler(&pstStr))
 150     {
 151         IOTIVITYTEST_LOG(ERROR, "[PMHelper] OCRegisterPersistentStorageHandler error");
 152         return false;
 153     }
 154
 155     // initialize OC stack and provisioning manager
 156     if (OC_STACK_OK != OCInit(NULL, 0, OC_CLIENT_SERVER))
 157     {
 158         IOTIVITYTEST_LOG(ERROR, "[PMHelper] OCStack init error");
 159         return false;
 160     }
 161
 162     if (access(PRVN_DB_FILE_NAME, F_OK) != -1)
 163     {
 164         IOTIVITYTEST_LOG(DEBUG, "[PMHelper] Provisioning DB file already exists.");
 165     }
 166     else
 167     {
 168         IOTIVITYTEST_LOG(DEBUG, "[PMHelper] No provisioning DB file, creating new ");
 169     }
 170
 171     IOTIVITYTEST_LOG(INFO, "************OCInitPM In************");
 172
 173     if (OC_STACK_OK != OCInitPM(chDBPath))
 174     {
 175         IOTIVITYTEST_LOG(ERROR, "[PMHelper] OCInitPM Error");
 176         return false;
 177     }
 178
 179     __FUNC_OUT__
 180     return true;
 181 }
 182
 183 bool PMCsdkCertHelper::provisionCRL(void* ctx, const OCProvisionDev_t *selectedDeviceInfo,
 184         OicSecCrl_t *crl, OCProvisionResultCB resultCallback, OCStackResult expectedResult)
 185 {
 186     __FUNC_IN__
 187
 188     PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
 189     OCStackResult result = OC_STACK_OK;
 190     //OCProvisionCRL(ctx, selectedDeviceInfo, crl, resultCallback);
 191
 192     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCProvisionCRL returns %s",
 193             CommonUtil::getOCStackResult(result));
 194
 195     if (expectedResult != result)
 196     {
 197         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
 198         return false;
 199     }
 200
 201     if (OC_STACK_OK == result)
 202     {
 203         if (CALLBACK_NOT_INVOKED == PMCsdkCertHelper::waitCallbackRet())
 204         {
 205             IOTIVITYTEST_LOG(ERROR, "[Cloud] CALLBACK_NOT_INVOKED");
 206             return false;
 207         }
 208     }
 209
 210     __FUNC_OUT__
 211     return true;
 212 }
 213
 214 bool PMCsdkCertHelper::provisionTrustCertChain(void *ctx, OicSecCredType_t type, uint16_t credId,
 215         const OCProvisionDev_t *selectedDeviceInfo, OCProvisionResultCB resultCallback,
 216         OCStackResult expectedResult)
 217 {
 218     __FUNC_IN__
 219
 220     PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
 221     OCStackResult result = OCProvisionTrustCertChain(ctx, type, credId, selectedDeviceInfo,
 222             resultCallback);
 223     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] provisionTrustCertChain returns %s",
 224             CommonUtil::getOCStackResult(result));
 225
 226     if (expectedResult != result)
 227     {
 228         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
 229         return false;
 230     }
 231
 232     if (OC_STACK_OK == result)
 233     {
 234         if (CALLBACK_NOT_INVOKED == PMCsdkCertHelper::waitCallbackRet())
 235         {
 236             IOTIVITYTEST_LOG(ERROR, "[Cloud] CALLBACK_NOT_INVOKED");
 237             return false;
 238         }
 239     }
 240
 241     __FUNC_OUT__
 242     return true;
 243 }
 244
 245 bool PMCsdkCertHelper::saveTrustCertChain(uint8_t *trustCertChain, size_t chainSize,
 246         OicEncodingType_t encodingType, uint16_t *credId, OCStackResult expectedResult)
 247 {
 248     __FUNC_IN__
 249
 250     PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
 251
 252     OCStackResult result = OCSaveTrustCertChain(trustCertChain, chainSize, encodingType, credId);
 253     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCSaveTrustCertChain returns %s",
 254             CommonUtil::getOCStackResult(result));
 255
 256     IOTIVITYTEST_LOG(INFO, "CredId of Saved Trust Cert. Chain into Cred of SVR : %d", *credId);
 257
 258     if (expectedResult != result)
 259     {
 260         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
 261         return false;
 262     }
 263
 264     IOTIVITYTEST_LOG(DEBUG, "saveTrustCertChain OUT");
 265     return true;
 266 }
 267
 268 bool PMCsdkCertHelper::registerTrustCertChainNotifier(void *cb, TrustCertChainChangeCB CB,
 269         OCStackResult expectedResult)
 270 {
 271     __FUNC_IN__
 272
 273     PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
 274
 275     OCStackResult result = OCRegisterTrustCertChainNotifier(cb, CB);
 276     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCRegisterTrustCertChainNotifier returns %s",
 277             CommonUtil::getOCStackResult(result));
 278
 279     if (expectedResult != result)
 280     {
 281         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
 282         return false;
 283     }
 284
 285     __FUNC_OUT__
 286     return true;
 287 }
 288
 289 bool PMCsdkCertHelper::removeTrustCertChainNotifier()
 290 {
 291     __FUNC_IN__
 292
 293     OCRemoveTrustCertChainNotifier();
 294
 295     __FUNC_OUT__
 296     return true;
 297 }
 298
 299 bool PMCsdkCertHelper::readTrustCertChain(uint16_t credId, uint8_t **trustCertChain,
 300         size_t *chainSize, OCStackResult expectedResult)
 301 {
 302     __FUNC_IN__
 303
 304     PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
 305
 306     OCStackResult result = OCReadTrustCertChain(credId, trustCertChain, chainSize);
 307
 308     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCReadTrustCertChain returns %s",
 309             CommonUtil::getOCStackResult(result));
 310
 311     if (expectedResult != result)
 312     {
 313         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
 314         return false;
 315     }
 316
 317     if (OC_STACK_OK == result && OC_STACK_OK == expectedResult)
 318     {
 319         OIC_LOG_BUFFER(DEBUG, TAG, *trustCertChain, *chainSize);
 320     }
 321
 322     __FUNC_OUT__
 323     return true;
 324 }
 325
 326 bool PMCsdkCertHelper::provisionCertificate(void *ctx, const OCProvisionDev_t *pDev,
 327         const char* pemCert, OCProvisionResultCB resultCallback, OCStackResult expectedResult)
 328 {
 329     __FUNC_IN__
 330
 331     PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
 332     OCStackResult result = OCProvisionCertificate(ctx, pDev, pemCert, resultCallback);
 333     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCProvisionCertificate returns %s",
 334             CommonUtil::getOCStackResult(result));
 335
 336     if (expectedResult != result)
 337     {
 338         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
 339         return false;
 340     }
 341
 342     if (OC_STACK_OK == result)
 343     {
 344         if (CALLBACK_NOT_INVOKED == PMCsdkCertHelper::waitCallbackRet())
 345         {
 346             IOTIVITYTEST_LOG(ERROR, "[Cloud] CALLBACK_NOT_INVOKED");
 347             return false;
 348         }
 349     }
 350
 351     __FUNC_OUT__
 352     return true;
 353 }
 354
 355 bool PMCsdkCertHelper::saveOwnCertChain(const char* cert, const char* key, uint16_t *credId,
 356         OCStackResult expectedResult)
 357 {
 358     __FUNC_IN__
 359
 360     PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
 361
 362     OCStackResult result = OCSaveOwnCertChain(cert, key, credId);
 363     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCSaveOwnCertChain returns %s",
 364             CommonUtil::getOCStackResult(result));
 365
 366     IOTIVITYTEST_LOG(INFO, "CredId of Saved Trust Cert. Chain into Cred of SVR : %d", *credId);
 367
 368     if (expectedResult != result)
 369     {
 370         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
 371         return false;
 372     }
 373
 374     IOTIVITYTEST_LOG(DEBUG, "OCSaveOwnCertChain OUT");
 375     return true;
 376 }
 377
 378 bool PMCsdkCertHelper::saveOwnRoleCert(const char* cert, uint16_t *credId,
 379         OCStackResult expectedResult)
 380 {
 381     __FUNC_IN__
 382
 383     PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
 384
 385     OCStackResult result = OCSaveOwnRoleCert(cert, credId);
 386     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCSaveOwnRoleCert returns %s",
 387             CommonUtil::getOCStackResult(result));
 388
 389     IOTIVITYTEST_LOG(INFO, "CredId of Saved Trust Cert. Chain into Cred of SVR : %d", *credId);
 390
 391     if (expectedResult != result)
 392     {
 393         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
 394         return false;
 395     }
 396
 397     IOTIVITYTEST_LOG(DEBUG, "OCSaveOwnCertChain OUT");
 398     return true;
 399 }
 400
 401 bool PMCsdkCertHelper::generateKeyPair(char **publicKey, size_t *publicKeyLen, char **privateKey,
 402         size_t *privateKeyLen, OCStackResult expectedResult)
 403 {
 404     __FUNC_IN__
 405
 406     OCStackResult result = OCGenerateKeyPair(publicKey, publicKeyLen, privateKey, privateKeyLen);
 407     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGenerateKeyPair returns %s",
 408             CommonUtil::getOCStackResult(result));
 409
 410     if (expectedResult != result)
 411     {
 412         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
 413         return false;
 414     }
 415
 416     IOTIVITYTEST_LOG(DEBUG, "OCGenerateKeyPair OUT");
 417     return true;
 418 }
 419
 420 bool PMCsdkCertHelper::generateRandomSerialNumber(char **serial, size_t *serialLen,
 421         OCStackResult expectedResult)
 422 {
 423     __FUNC_IN__
 424
 425     OCStackResult result = OCGenerateRandomSerialNumber(serial, serialLen);
 426     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGenerateRandomSerialNumber returns %s",
 427             CommonUtil::getOCStackResult(result));
 428
 429     if (expectedResult != result)
 430     {
 431         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
 432         return false;
 433     }
 434
 435     IOTIVITYTEST_LOG(DEBUG, "OCGenerateRandomSerialNumber OUT");
 436     return true;
 437 }
 438
 439 bool PMCsdkCertHelper::generateCACertificate(const char *subject, const char *subjectPublicKey,
 440         const char *issuerCert, const char *issuerPrivateKey, const char *serial,
 441         const char *notValidBefore, const char *notValidAfter, char **certificate,
 442         size_t *certificateLen, OCStackResult expectedResult)
 443 {
 444     __FUNC_IN__
 445
 446     OCStackResult result = OCGenerateRootCACertificate(subject, subjectPublicKey, issuerCert,
 447             issuerPrivateKey, serial, notValidBefore, notValidAfter, certificate, certificateLen);
 448     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGenerateRootCACertificate returns %s",
 449             CommonUtil::getOCStackResult(result));
 450
 451     if (expectedResult != result)
 452     {
 453         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
 454         return false;
 455     }
 456
 457     IOTIVITYTEST_LOG(DEBUG, "OCGenerateRootCACertificate OUT");
 458     return true;
 459 }
 460
 461 bool PMCsdkCertHelper::getDeviceId(OCUUIdentity *deviceId, OCStackResult expectedResult)
 462 {
 463     __FUNC_IN__
 464
 465     OCStackResult result = OCGetDeviceId(deviceId);
 466     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGetDeviceId returns %s",
 467             CommonUtil::getOCStackResult(result));
 468
 469     if (expectedResult != result)
 470     {
 471         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
 472         return false;
 473     }
 474
 475     IOTIVITYTEST_LOG(DEBUG, "OCGetDeviceId OUT");
 476     return true;
 477 }
 478
 479 bool PMCsdkCertHelper::getUuidFromCSR(const char* csr, OicUuid_t* uuid,
 480         OCStackResult expectedResult)
 481 {
 482     __FUNC_IN__
 483
 484     OCStackResult result = OCGetUuidFromCSR(csr, uuid);
 485     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGetUuidFromCSR returns %s",
 486             CommonUtil::getOCStackResult(result));
 487
 488     if (expectedResult != result)
 489     {
 490         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
 491         return false;
 492     }
 493
 494     IOTIVITYTEST_LOG(DEBUG, "OCGetUuidFromCSR OUT");
 495     return true;
 496 }
 497
 498 bool PMCsdkCertHelper::getPublicKeyFromCSR(const char* csr, char** publicKey,
 499         OCStackResult expectedResult)
 500 {
 501     __FUNC_IN__
 502
 503     OCStackResult result = OCGetPublicKeyFromCSR(csr, publicKey);
 504     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGetPublicKeyFromCSR returns %s",
 505             CommonUtil::getOCStackResult(result));
 506
 507     if (expectedResult != result)
 508     {
 509         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
 510         return false;
 511     }
 512
 513     IOTIVITYTEST_LOG(DEBUG, "OCGetPublicKeyFromCSR OUT");
 514     return true;
 515 }
 516
 517 bool PMCsdkCertHelper::generateIdentityCertificate(const OicUuid_t *subjectUuid,
 518         const char *subjectPublicKey, const char *issuerCert, const char *issuerPrivateKey,
 519         const char *serial, const char *notValidBefore, const char *notValidAfter,
 520         char **certificate, size_t *certificateLen, OCStackResult expectedResult)
 521 {
 522     __FUNC_IN__
 523
 524     OCStackResult result = OCGenerateIdentityCertificate(subjectUuid, subjectPublicKey, issuerCert,
 525             issuerPrivateKey, serial, notValidBefore, notValidAfter, certificate, certificateLen);
 526     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGenerateIdentityCertificate returns %s",
 527             CommonUtil::getOCStackResult(result));
 528
 529     if (expectedResult != result)
 530     {
 531         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
 532         return false;
 533     }
 534
 535     IOTIVITYTEST_LOG(DEBUG, "OCGenerateIdentityCertificate OUT");
 536     return true;
 537 }
 538
 539 /**
 540  * Helper Method for OCGetCSRResource
 541  */
 542 bool PMCsdkCertHelper::getCSRResource(void* ctx, const OCProvisionDev_t *selectedDeviceInfo,
 543         OCGetCSRResultCB resultCallback, OCStackResult expectedResult)
 544 {
 545     __FUNC_IN__
 546
 547     PMCsdkCallbackHelper::s_CBInvoked = false;
 548
 549     OCStackResult res = OCGetCSRResource(ctx, selectedDeviceInfo, resultCallback);
 550     IOTIVITYTEST_LOG(INFO, "[Cloud Acl]  OCGetCSRResource API returns: %s",
 551             CommonUtil::getOCStackResult(res));
 552
 553     if (expectedResult != res)
 554     {
 555         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(res, expectedResult);
 556         return false;
 557     }
 558
 559     if (OC_STACK_OK == res)
 560     {
 561         if (CALLBACK_NOT_INVOKED == PMCsdkCertHelper::waitCallbackRet())
 562         {
 563             m_failureMessage = PMCsdkUtilityHelper::setFailureMessage("CALLBACK Not invoked");
 564             return false;
 565         }
 566     }
 567
 568     __FUNC_OUT__
 569     return true;
 570 }
 571
 572 bool PMCsdkCertHelper::verifyCSRSignature(const char* csr, OCStackResult expectedResult)
 573 {
 574     __FUNC_IN__
 575
 576     OCStackResult result = OCVerifyCSRSignature(csr);
 577     IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCVerifyCSRSignature returns %s",
 578             CommonUtil::getOCStackResult(result));
 579
 580     if (expectedResult != result)
 581     {
 582         m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
 583         return false;
 584     }
 585
 586     IOTIVITYTEST_LOG(DEBUG, "OCVerifyCSRSignature OUT");
 587     return true;
 588 }
 589
 590 bool PMCsdkCertHelper::readFile(const char *name, OCByteString *out)
 591 {
 592     FILE *file = NULL;
 593     int length = 0;
 594     uint8_t *buffer = NULL;
 595     bool result = false;
 596     size_t count, realCount;
 597     //Open file
 598     file = fopen(name, "rb");
 599     if (!file)
 600     {
 601         IOTIVITYTEST_LOG(ERROR, "Unable to open file %s", name);
 602         return result;
 603     }
 604
 605     //Get file length
 606     if (fseek(file, 0, SEEK_END))
 607     {
 608         IOTIVITYTEST_LOG(ERROR, "Failed to SEEK_END");
 609         goto exit;
 610     }
 611
 612     length = ftell(file);
 613     if (length < 0)
 614     {
 615         IOTIVITYTEST_LOG(ERROR, "Failed to ftell");
 616         goto exit;
 617     }
 618
 619     if (fseek(file, 0, SEEK_SET))
 620     {
 621         IOTIVITYTEST_LOG(ERROR, "Failed to SEEK_SET");
 622         goto exit;
 623     }
 624
 625     //Allocate memory
 626     buffer = (uint8_t *) malloc(length);
 627     if (!buffer)
 628     {
 629         IOTIVITYTEST_LOG(ERROR, "Failed to allocate buffer");
 630         goto exit;
 631     }
 632
 633     //Read file contents into buffer
 634     count = 1;
 635     realCount = fread(buffer, length, count, file);
 636     if (realCount != count)
 637     {
 638         IOTIVITYTEST_LOG(ERROR, "Read %d bytes %zu times instead of %zu", length, realCount, count);
 639         goto exit;
 640     }
 641
 642     out->bytes = buffer;
 643     out->len = length;
 644
 645     result = true;
 646     exit: fclose(file);
 647     return result;
 648 }
 649
 650 ByteArray_t PMCsdkCertHelper::getTrustCertChainArray()
 651 {
 652     __FUNC_IN__
 653
 654     ByteArray trustCertChainArray =
 655     { 0, 0 };
 656
 657     FILE *fp = fopen("rootca.crt", "rb+");
 658
 659     if (fp)
 660     {
 661         size_t fsize;
 662 #ifdef __WINDOWS__
 663         if (_fseeki64(fp, 0, SEEK_END) == 0 && (fsize = _ftelli64(fp)) > 0)
 664 #else
 665         if (fseeko(fp, 0, SEEK_END) == 0 && (fsize = ftello(fp)) > 0)
 666 #endif
 667         {
 668             trustCertChainArray.data = (uint8_t *) malloc(fsize);
 669             trustCertChainArray.len = fsize;
 670             if (NULL != trustCertChainArray.data)
 671             {
 672                 rewind(fp);
 673
 674                 if (fsize != fread(trustCertChainArray.data, 1, fsize, fp))
 675                 {
 676                     IOTIVITYTEST_LOG(ERROR, "Certiface not read completely");
 677                 }
 678
 679                 fclose(fp);
 680                 return trustCertChainArray;
 681             }
 682
 683             cout << "Failed to allocate memory" << endl;
 684             fclose(fp);
 685         }
 686     }
 687
 688     __FUNC_OUT__
 689     return trustCertChainArray;
 690 }
 691
 692 std::string PMCsdkCertHelper::getFailureMessage()
 693 {
 694     return m_failureMessage;
 695 }