1 /******************************************************************
3 * Copyright 2017 Samsung Electronics All Rights Reserved.
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
20 ******************************************************************/
21 #include "PMCsdkCertHelper.h"
22 #include "PMCsdkCallbackHelper.h"
23 #include "PMCsdkUtilityHelper.h"
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 =
31 ByteArray s_trustCertChainArray =
34 FILE* PMCsdkCertHelper::fopenProvManager(const char* path, const char* mode)
37 return fopen(SVR_DB_FILE_NAME, mode);
40 int PMCsdkCertHelper::waitCallbackRet(void)
44 for (int i = 0; CALLBACK_TIMEOUT > i; ++i)
46 IOTIVITYTEST_LOG(DEBUG, "PMCsdkCertHelper::waitCallbackRet Loop = %d", i);
48 if (true == PMCsdkCallbackHelper::s_CBInvoked)
50 return CALLBACK_INVOKED;
53 CommonUtil::waitInSecond(DELAY_SHORT);
55 if (OC_STACK_OK != OCProcess())
57 IOTIVITYTEST_LOG(ERROR, "OCStack process error");
58 return CALLBACK_NOT_INVOKED;
63 return CALLBACK_NOT_INVOKED;
68 void PMCsdkCertHelper::trustCertChainChangeCB(void *ctx, uint16_t credId, uint8_t *trustCertChain,
73 IOTIVITYTEST_LOG(INFO, "Provision Cert SUCCEEDED - ctx: %s", (char* ) ctx);
75 IOTIVITYTEST_LOG(INFO, "CRED ID : %d", credId);
77 OIC_LOG_BUFFER(DEBUG, "Cert Cb", trustCertChain, chainSize);
79 PMCsdkCallbackHelper::s_CBInvoked= true;
84 void PMCsdkCertHelper::getCsrForCertProvCB(void* ctx, size_t nOfRes, OCPMGetCsrResult_t* arr,
91 IOTIVITYTEST_LOG(ERROR, "getCsrForCertProvCB FAILED - ctx: %s", (char* )ctx);
94 if (arr[0].encoding == OIC_ENCODING_DER)
96 OCStackResult res = OCConvertDerCSRToPem((char*) arr[0].csr, arr[0].csrLen, &g_csrVal);
97 if (res != OC_STACK_OK)
99 IOTIVITYTEST_LOG(ERROR,
100 "getCsrForCertProvCB FAILED (CSR re-encoding failed) - error: %d, ctx: %s",
103 PMCsdkCallbackHelper::s_CBInvoked= true;
105 else if (arr[0].encoding == OIC_ENCODING_PEM)
107 g_csrVal = (char*) OICCalloc(1, arr[0].csrLen);
108 if (g_csrVal == NULL)
110 IOTIVITYTEST_LOG(ERROR, "getCsrForCertProvCB FAILED (memory allocation) - ctx: %s",
114 memcpy(g_csrVal, arr[0].csr, arr[0].csrLen);
116 IOTIVITYTEST_LOG(INFO, "getCsrForCertProvCB success");
117 PMCsdkCallbackHelper::s_CBInvoked= true;
121 IOTIVITYTEST_LOG(ERROR, "getCsrForCertProvCB FAILED (unknown encoding) - ctx: %s",
127 IOTIVITYTEST_LOG(ERROR, "getCsrForCertProvCB FAILED - ctx: %s", (char* )ctx);
132 // CAPI for Provisioning Manager
134 PMCsdkCertHelper::PMCsdkCertHelper()
136 IOTIVITYTEST_LOG(DEBUG, "[PMHelper] Constructor");
139 bool PMCsdkCertHelper::initProvisionClient(int clientOTMType, char* chDBPath)
143 pstStr.open = PMCsdkCertHelper::fopenProvManager;
145 pstStr.write = fwrite;
146 pstStr.close = fclose;
147 pstStr.unlink = unlink;
149 if (OC_STACK_OK != OCRegisterPersistentStorageHandler(&pstStr))
151 IOTIVITYTEST_LOG(ERROR, "[PMHelper] OCRegisterPersistentStorageHandler error");
155 // initialize OC stack and provisioning manager
156 if (OC_STACK_OK != OCInit(NULL, 0, OC_CLIENT_SERVER))
158 IOTIVITYTEST_LOG(ERROR, "[PMHelper] OCStack init error");
162 if (access(PRVN_DB_FILE_NAME, F_OK) != -1)
164 IOTIVITYTEST_LOG(DEBUG, "[PMHelper] Provisioning DB file already exists.");
168 IOTIVITYTEST_LOG(DEBUG, "[PMHelper] No provisioning DB file, creating new ");
171 IOTIVITYTEST_LOG(INFO, "************OCInitPM In************");
173 if (OC_STACK_OK != OCInitPM(chDBPath))
175 IOTIVITYTEST_LOG(ERROR, "[PMHelper] OCInitPM Error");
183 bool PMCsdkCertHelper::provisionCRL(void* ctx, const OCProvisionDev_t *selectedDeviceInfo,
184 OicSecCrl_t *crl, OCProvisionResultCB resultCallback, OCStackResult expectedResult)
188 PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
189 OCStackResult result = OC_STACK_OK;
190 //OCProvisionCRL(ctx, selectedDeviceInfo, crl, resultCallback);
192 IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCProvisionCRL returns %s",
193 CommonUtil::getOCStackResult(result));
195 if (expectedResult != result)
197 m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
201 if (OC_STACK_OK == result)
203 if (CALLBACK_NOT_INVOKED == PMCsdkCertHelper::waitCallbackRet())
205 IOTIVITYTEST_LOG(ERROR, "[Cloud] CALLBACK_NOT_INVOKED");
214 bool PMCsdkCertHelper::provisionTrustCertChain(void *ctx, OicSecCredType_t type, uint16_t credId,
215 const OCProvisionDev_t *selectedDeviceInfo, OCProvisionResultCB resultCallback,
216 OCStackResult expectedResult)
220 PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
221 OCStackResult result = OCProvisionTrustCertChain(ctx, type, credId, selectedDeviceInfo,
223 IOTIVITYTEST_LOG(INFO, "[Cloud Acl] provisionTrustCertChain returns %s",
224 CommonUtil::getOCStackResult(result));
226 if (expectedResult != result)
228 m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
232 if (OC_STACK_OK == result)
234 if (CALLBACK_NOT_INVOKED == PMCsdkCertHelper::waitCallbackRet())
236 IOTIVITYTEST_LOG(ERROR, "[Cloud] CALLBACK_NOT_INVOKED");
245 bool PMCsdkCertHelper::saveTrustCertChain(uint8_t *trustCertChain, size_t chainSize,
246 OicEncodingType_t encodingType, uint16_t *credId, OCStackResult expectedResult)
250 PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
252 OCStackResult result = OCSaveTrustCertChain(trustCertChain, chainSize, encodingType, credId);
253 IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCSaveTrustCertChain returns %s",
254 CommonUtil::getOCStackResult(result));
256 IOTIVITYTEST_LOG(INFO, "CredId of Saved Trust Cert. Chain into Cred of SVR : %d", *credId);
258 if (expectedResult != result)
260 m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
264 IOTIVITYTEST_LOG(DEBUG, "saveTrustCertChain OUT");
268 bool PMCsdkCertHelper::registerTrustCertChainNotifier(void *cb, TrustCertChainChangeCB CB,
269 OCStackResult expectedResult)
273 PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
275 OCStackResult result = OCRegisterTrustCertChainNotifier(cb, CB);
276 IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCRegisterTrustCertChainNotifier returns %s",
277 CommonUtil::getOCStackResult(result));
279 if (expectedResult != result)
281 m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
289 bool PMCsdkCertHelper::removeTrustCertChainNotifier()
293 OCRemoveTrustCertChainNotifier();
299 bool PMCsdkCertHelper::readTrustCertChain(uint16_t credId, uint8_t **trustCertChain,
300 size_t *chainSize, OCStackResult expectedResult)
304 PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
306 OCStackResult result = OCReadTrustCertChain(credId, trustCertChain, chainSize);
308 IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCReadTrustCertChain returns %s",
309 CommonUtil::getOCStackResult(result));
311 if (expectedResult != result)
313 m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
317 if (OC_STACK_OK == result && OC_STACK_OK == expectedResult)
319 OIC_LOG_BUFFER(DEBUG, TAG, *trustCertChain, *chainSize);
326 bool PMCsdkCertHelper::provisionCertificate(void *ctx, const OCProvisionDev_t *pDev,
327 const char* pemCert, OCProvisionResultCB resultCallback, OCStackResult expectedResult)
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));
336 if (expectedResult != result)
338 m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
342 if (OC_STACK_OK == result)
344 if (CALLBACK_NOT_INVOKED == PMCsdkCertHelper::waitCallbackRet())
346 IOTIVITYTEST_LOG(ERROR, "[Cloud] CALLBACK_NOT_INVOKED");
355 bool PMCsdkCertHelper::saveOwnCertChain(const char* cert, const char* key, uint16_t *credId,
356 OCStackResult expectedResult)
360 PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
362 OCStackResult result = OCSaveOwnCertChain(cert, key, credId);
363 IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCSaveOwnCertChain returns %s",
364 CommonUtil::getOCStackResult(result));
366 IOTIVITYTEST_LOG(INFO, "CredId of Saved Trust Cert. Chain into Cred of SVR : %d", *credId);
368 if (expectedResult != result)
370 m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
374 IOTIVITYTEST_LOG(DEBUG, "OCSaveOwnCertChain OUT");
378 bool PMCsdkCertHelper::saveOwnRoleCert(const char* cert, uint16_t *credId,
379 OCStackResult expectedResult)
383 PMCsdkCallbackHelper::s_CBInvoked= CALLBACK_NOT_INVOKED;
385 OCStackResult result = OCSaveOwnRoleCert(cert, credId);
386 IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCSaveOwnRoleCert returns %s",
387 CommonUtil::getOCStackResult(result));
389 IOTIVITYTEST_LOG(INFO, "CredId of Saved Trust Cert. Chain into Cred of SVR : %d", *credId);
391 if (expectedResult != result)
393 m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
397 IOTIVITYTEST_LOG(DEBUG, "OCSaveOwnCertChain OUT");
401 bool PMCsdkCertHelper::generateKeyPair(char **publicKey, size_t *publicKeyLen, char **privateKey,
402 size_t *privateKeyLen, OCStackResult expectedResult)
406 OCStackResult result = OCGenerateKeyPair(publicKey, publicKeyLen, privateKey, privateKeyLen);
407 IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGenerateKeyPair returns %s",
408 CommonUtil::getOCStackResult(result));
410 if (expectedResult != result)
412 m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
416 IOTIVITYTEST_LOG(DEBUG, "OCGenerateKeyPair OUT");
420 bool PMCsdkCertHelper::generateRandomSerialNumber(char **serial, size_t *serialLen,
421 OCStackResult expectedResult)
425 OCStackResult result = OCGenerateRandomSerialNumber(serial, serialLen);
426 IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGenerateRandomSerialNumber returns %s",
427 CommonUtil::getOCStackResult(result));
429 if (expectedResult != result)
431 m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
435 IOTIVITYTEST_LOG(DEBUG, "OCGenerateRandomSerialNumber OUT");
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)
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));
451 if (expectedResult != result)
453 m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
457 IOTIVITYTEST_LOG(DEBUG, "OCGenerateRootCACertificate OUT");
461 bool PMCsdkCertHelper::getDeviceId(OCUUIdentity *deviceId, OCStackResult expectedResult)
465 OCStackResult result = OCGetDeviceId(deviceId);
466 IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGetDeviceId returns %s",
467 CommonUtil::getOCStackResult(result));
469 if (expectedResult != result)
471 m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
475 IOTIVITYTEST_LOG(DEBUG, "OCGetDeviceId OUT");
479 bool PMCsdkCertHelper::getUuidFromCSR(const char* csr, OicUuid_t* uuid,
480 OCStackResult expectedResult)
484 OCStackResult result = OCGetUuidFromCSR(csr, uuid);
485 IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGetUuidFromCSR returns %s",
486 CommonUtil::getOCStackResult(result));
488 if (expectedResult != result)
490 m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
494 IOTIVITYTEST_LOG(DEBUG, "OCGetUuidFromCSR OUT");
498 bool PMCsdkCertHelper::getPublicKeyFromCSR(const char* csr, char** publicKey,
499 OCStackResult expectedResult)
503 OCStackResult result = OCGetPublicKeyFromCSR(csr, publicKey);
504 IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGetPublicKeyFromCSR returns %s",
505 CommonUtil::getOCStackResult(result));
507 if (expectedResult != result)
509 m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
513 IOTIVITYTEST_LOG(DEBUG, "OCGetPublicKeyFromCSR OUT");
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)
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));
529 if (expectedResult != result)
531 m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
535 IOTIVITYTEST_LOG(DEBUG, "OCGenerateIdentityCertificate OUT");
540 * Helper Method for OCGetCSRResource
542 bool PMCsdkCertHelper::getCSRResource(void* ctx, const OCProvisionDev_t *selectedDeviceInfo,
543 OCGetCSRResultCB resultCallback, OCStackResult expectedResult)
547 PMCsdkCallbackHelper::s_CBInvoked = false;
549 OCStackResult res = OCGetCSRResource(ctx, selectedDeviceInfo, resultCallback);
550 IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCGetCSRResource API returns: %s",
551 CommonUtil::getOCStackResult(res));
553 if (expectedResult != res)
555 m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(res, expectedResult);
559 if (OC_STACK_OK == res)
561 if (CALLBACK_NOT_INVOKED == PMCsdkCertHelper::waitCallbackRet())
563 m_failureMessage = PMCsdkUtilityHelper::setFailureMessage("CALLBACK Not invoked");
572 bool PMCsdkCertHelper::verifyCSRSignature(const char* csr, OCStackResult expectedResult)
576 OCStackResult result = OCVerifyCSRSignature(csr);
577 IOTIVITYTEST_LOG(INFO, "[Cloud Acl] OCVerifyCSRSignature returns %s",
578 CommonUtil::getOCStackResult(result));
580 if (expectedResult != result)
582 m_failureMessage = PMCsdkUtilityHelper::setFailureMessage(result, expectedResult);
586 IOTIVITYTEST_LOG(DEBUG, "OCVerifyCSRSignature OUT");
590 bool PMCsdkCertHelper::readFile(const char *name, OCByteString *out)
594 uint8_t *buffer = NULL;
596 size_t count, realCount;
598 file = fopen(name, "rb");
601 IOTIVITYTEST_LOG(ERROR, "Unable to open file %s", name);
606 if (fseek(file, 0, SEEK_END))
608 IOTIVITYTEST_LOG(ERROR, "Failed to SEEK_END");
612 length = ftell(file);
615 IOTIVITYTEST_LOG(ERROR, "Failed to ftell");
619 if (fseek(file, 0, SEEK_SET))
621 IOTIVITYTEST_LOG(ERROR, "Failed to SEEK_SET");
626 buffer = (uint8_t *) malloc(length);
629 IOTIVITYTEST_LOG(ERROR, "Failed to allocate buffer");
633 //Read file contents into buffer
635 realCount = fread(buffer, length, count, file);
636 if (realCount != count)
638 IOTIVITYTEST_LOG(ERROR, "Read %d bytes %zu times instead of %zu", length, realCount, count);
650 ByteArray_t PMCsdkCertHelper::getTrustCertChainArray()
654 ByteArray trustCertChainArray =
657 FILE *fp = fopen("rootca.crt", "rb+");
663 if (_fseeki64(fp, 0, SEEK_END) == 0 && (fsize = _ftelli64(fp)) > 0)
665 if (fseeko(fp, 0, SEEK_END) == 0 && (fsize = ftello(fp)) > 0)
668 trustCertChainArray.data = (uint8_t *) malloc(fsize);
669 trustCertChainArray.len = fsize;
670 if (NULL != trustCertChainArray.data)
674 if (fsize != fread(trustCertChainArray.data, 1, fsize, fp))
676 IOTIVITYTEST_LOG(ERROR, "Certiface not read completely");
680 return trustCertChainArray;
683 cout << "Failed to allocate memory" << endl;
689 return trustCertChainArray;
692 std::string PMCsdkCertHelper::getFailureMessage()
694 return m_failureMessage;