1 //******************************************************************
3 // Copyright 2015 Intel Mobile Communications GmbH All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
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.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
24 #include "cainterface.h"
25 #include "resourcemanager.h"
26 #include "credresource.h"
27 #include "doxmresource.h"
28 #include "pstatresource.h"
29 #include "policyengine.h"
30 #include "srmutility.h"
31 #include "psinterface.h"
33 #include "oic_string.h"
34 #include "oic_malloc.h"
35 #include "securevirtualresourcetypes.h"
36 #include "secureresourcemanager.h"
37 #include "srmresourcestrings.h"
38 #include "ocresourcehandler.h"
40 #if defined( __WITH_TLS__) || defined(__WITH_DTLS__)
41 #include "pkix_interface.h"
42 #endif //__WITH_TLS__ or __WITH_DTLS__
45 //Request Callback handler
46 static CARequestCallback gRequestHandler = NULL;
47 //Response Callback handler
48 static CAResponseCallback gResponseHandler = NULL;
49 //Error Callback handler
50 static CAErrorCallback gErrorHandler = NULL;
51 //Persistent Storage callback handler for open/read/write/close/unlink
52 static OCPersistentStorage *gPersistentStorageHandler = NULL;
53 //Provisioning response callback
54 static SPResponseCallback gSPResponseHandler = NULL;
57 * A single global Policy Engine context will suffice as long
58 * as SRM is single-threaded.
60 PEContext_t g_policyEngineContext;
63 * Function to register provisoning API's response callback.
64 * @param respHandler response handler callback.
66 void SRMRegisterProvisioningResponseHandler(SPResponseCallback respHandler)
68 gSPResponseHandler = respHandler;
71 void SetResourceRequestType(PEContext_t *context, const char *resourceUri)
73 context->resourceType = GetSvrTypeFromUri(resourceUri);
76 static void SRMSendUnAuthorizedAccessresponse(PEContext_t *context)
78 CAResponseInfo_t responseInfo = {.result = CA_EMPTY};
80 if (NULL == context ||
81 NULL == context->amsMgrContext->requestInfo)
83 OIC_LOG_V(ERROR, TAG, "%s : NULL Parameter(s)",__func__);
87 memcpy(&responseInfo.info, &(context->amsMgrContext->requestInfo->info),
88 sizeof(responseInfo.info));
89 responseInfo.info.payload = NULL;
90 responseInfo.result = CA_UNAUTHORIZED_REQ;
91 responseInfo.info.dataType = CA_RESPONSE_DATA;
93 if (CA_STATUS_OK == CASendResponse(context->amsMgrContext->endpoint, &responseInfo))
95 OIC_LOG(DEBUG, TAG, "Succeed in sending response to a unauthorized request!");
99 OIC_LOG(ERROR, TAG, "Failed in sending response to a unauthorized request!");
103 void SRMSendResponse(SRMAccessResponse_t responseVal)
105 OIC_LOG(DEBUG, TAG, "Sending response to remote device");
107 if (IsAccessGranted(responseVal) && gRequestHandler)
109 OIC_LOG_V(INFO, TAG, "%s : Access granted. Passing Request to RI layer", __func__);
110 if (!g_policyEngineContext.amsMgrContext->endpoint ||
111 !g_policyEngineContext.amsMgrContext->requestInfo)
113 OIC_LOG_V(ERROR, TAG, "%s : Invalid arguments", __func__);
114 SRMSendUnAuthorizedAccessresponse(&g_policyEngineContext);
117 gRequestHandler(g_policyEngineContext.amsMgrContext->endpoint,
118 g_policyEngineContext.amsMgrContext->requestInfo);
122 OIC_LOG_V(INFO, TAG, "%s : ACCESS_DENIED.", __func__);
123 SRMSendUnAuthorizedAccessresponse(&g_policyEngineContext);
127 //Resetting PE state to AWAITING_REQUEST
128 SetPolicyEngineState(&g_policyEngineContext, AWAITING_REQUEST);
132 * Handle the request from the SRM.
134 * @param endPoint object from which the response is received.
135 * @param requestInfo contains information for the request.
137 void SRMRequestHandler(const CAEndpoint_t *endPoint, const CARequestInfo_t *requestInfo)
139 OIC_LOG_V(DEBUG, TAG, "%s:Received request from remote device", __func__);
141 bool isRequestOverSecureChannel = false;
142 if (!endPoint || !requestInfo)
144 OIC_LOG(ERROR, TAG, "Invalid arguments");
148 // Copy the subjectID
149 OicUuid_t subjectId = {.id = {0}};
150 memcpy(subjectId.id, requestInfo->info.identity.id, sizeof(subjectId.id));
151 if (endPoint->flags & CA_SECURE)
153 OIC_LOG(INFO, TAG, "request over secure channel");
154 isRequestOverSecureChannel = true;
157 //Check the URI has the query and skip it before checking the permission
158 if (NULL == requestInfo->info.resourceUri)
160 OIC_LOG(ERROR, TAG, "Invalid resourceUri");
164 char *uri = strstr(requestInfo->info.resourceUri, "?");
168 //Skip query and pass the resource uri
169 position = uri - requestInfo->info.resourceUri;
173 position = strlen(requestInfo->info.resourceUri);
175 if (MAX_URI_LENGTH < position || 0 > position)
177 OIC_LOG(ERROR, TAG, "Incorrect URI length");
180 SRMAccessResponse_t response = ACCESS_DENIED;
181 char newUri[MAX_URI_LENGTH + 1];
182 OICStrcpyPartial(newUri, MAX_URI_LENGTH + 1, requestInfo->info.resourceUri, position);
184 SetResourceRequestType(&g_policyEngineContext, newUri);
186 // Form a 'Error', 'slow response' or 'access deny' response and send to peer
187 CAResponseInfo_t responseInfo = {.result = CA_EMPTY};
188 memcpy(&responseInfo.info, &(requestInfo->info), sizeof(responseInfo.info));
189 responseInfo.info.payload = NULL;
190 responseInfo.info.dataType = CA_RESPONSE_DATA;
192 OCResource *resPtr = FindResourceByUri(newUri);
195 // All vertical secure resources and SVR resources other than DOXM & PSTAT should reject request
197 if ((((resPtr->resourceProperties) & OC_SECURE)
198 && (g_policyEngineContext.resourceType == NOT_A_SVR_RESOURCE))
199 || ((g_policyEngineContext.resourceType < OIC_SEC_SVR_TYPE_COUNT)
200 && (g_policyEngineContext.resourceType != OIC_R_DOXM_TYPE)
201 && (g_policyEngineContext.resourceType != OIC_R_PSTAT_TYPE)))
203 // if resource is secure and request is over insecure channel
204 if (!isRequestOverSecureChannel)
206 // Reject all the requests over coap for secure resource.
207 responseInfo.result = CA_FORBIDDEN_REQ;
208 if (CA_STATUS_OK != CASendResponse(endPoint, &responseInfo))
210 OIC_LOG(ERROR, TAG, "Failed in sending response to a unauthorized request!");
216 #ifdef MULTIPLE_OWNER
218 * In case of ACL and CRED, The payload required to verify the payload.
219 * Payload information will be used for subowner's permission verification.
221 g_policyEngineContext.payload = (uint8_t*)requestInfo->info.payload;
222 g_policyEngineContext.payloadSize = requestInfo->info.payloadSize;
223 #endif //MULTIPLE_OWNER
225 //New request are only processed if the policy engine state is AWAITING_REQUEST.
226 if (AWAITING_REQUEST == g_policyEngineContext.state)
228 OIC_LOG_V(DEBUG, TAG, "Processing request with uri, %s for method, %d",
229 requestInfo->info.resourceUri, requestInfo->method);
230 response = CheckPermission(&g_policyEngineContext, &subjectId, newUri,
231 GetPermissionFromCAMethod_t(requestInfo->method));
235 OIC_LOG_V(INFO, TAG, "PE state %d. Ignoring request with uri, %s for method, %d",
236 g_policyEngineContext.state, requestInfo->info.resourceUri, requestInfo->method);
239 if (IsAccessGranted(response) && gRequestHandler)
241 gRequestHandler(endPoint, requestInfo);
245 VERIFY_NON_NULL(TAG, gRequestHandler, ERROR);
247 if (ACCESS_WAITING_FOR_AMS == response)
249 OIC_LOG(INFO, TAG, "Sending slow response");
251 UpdateAmsMgrContext(&g_policyEngineContext, endPoint, requestInfo);
252 responseInfo.result = CA_EMPTY;
253 responseInfo.info.type = CA_MSG_ACKNOWLEDGE;
258 * TODO Enhance this logic more to decide between
259 * CA_UNAUTHORIZED_REQ or CA_FORBIDDEN_REQ depending
260 * upon SRMAccessResponseReasonCode_t
262 OIC_LOG(INFO, TAG, "Sending for regular response");
263 responseInfo.result = CA_UNAUTHORIZED_REQ;
266 if (CA_STATUS_OK != CASendResponse(endPoint, &responseInfo))
268 OIC_LOG(ERROR, TAG, "Failed in sending response to a unauthorized request!");
272 responseInfo.result = CA_INTERNAL_SERVER_ERROR;
273 if (CA_STATUS_OK != CASendResponse(endPoint, &responseInfo))
275 OIC_LOG(ERROR, TAG, "Failed in sending response to a unauthorized request!");
280 * Handle the response from the SRM.
282 * @param endPoint points to the remote endpoint.
283 * @param responseInfo contains response information from the endpoint.
285 void SRMResponseHandler(const CAEndpoint_t *endPoint, const CAResponseInfo_t *responseInfo)
287 OIC_LOG_V(DEBUG, TAG, "%s:Received response from remote device", __func__);
289 // isProvResponse flag is to check whether response is catered by provisioning APIs or not.
290 // When token sent by CA response matches with token generated by provisioning request,
291 // gSPResponseHandler returns true and response is not sent to RI layer. In case
292 // gSPResponseHandler is null and isProvResponse is false response then the response is for
294 bool isProvResponse = false;
296 if (gSPResponseHandler)
298 isProvResponse = gSPResponseHandler(endPoint, responseInfo);
300 if (!isProvResponse && gResponseHandler)
302 gResponseHandler(endPoint, responseInfo);
307 * Handle the error from the SRM.
309 * @param endPoint is the remote endpoint.
310 * @param errorInfo contains error information from the endpoint.
312 void SRMErrorHandler(const CAEndpoint_t *endPoint, const CAErrorInfo_t *errorInfo)
314 OIC_LOG_V(INFO, TAG, "%s:Received error from remote device with result, %d for request uri, %s",
315 __func__, errorInfo->result, errorInfo->info.resourceUri);
318 gErrorHandler(endPoint, errorInfo);
322 OCStackResult SRMRegisterHandler(CARequestCallback reqHandler,
323 CAResponseCallback respHandler,
324 CAErrorCallback errHandler)
326 OIC_LOG(DEBUG, TAG, "SRMRegisterHandler !!");
327 if( !reqHandler || !respHandler || !errHandler)
329 OIC_LOG(ERROR, TAG, "Callback handlers are invalid");
330 return OC_STACK_INVALID_PARAM;
332 gRequestHandler = reqHandler;
333 gResponseHandler = respHandler;
334 gErrorHandler = errHandler;
337 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
338 CARegisterHandler(SRMRequestHandler, SRMResponseHandler, SRMErrorHandler);
340 CARegisterHandler(reqHandler, respHandler, errHandler);
341 #endif /* __WITH_DTLS__ */
345 OCStackResult SRMRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
347 OIC_LOG(DEBUG, TAG, "SRMRegisterPersistentStorageHandler !!");
348 if(!persistentStorageHandler)
350 OIC_LOG(ERROR, TAG, "The persistent storage handler is invalid");
351 return OC_STACK_INVALID_PARAM;
354 gPersistentStorageHandler = persistentStorageHandler;
356 // Check validity of Persistent Storage
357 OCStackResult res = OC_STACK_SVR_DB_NOT_EXIST;
358 res = CheckPersistentStorage(persistentStorageHandler);
359 if (OC_STACK_OK != res)
361 OIC_LOG(ERROR, TAG, "Persistent storage is not normal");
362 gPersistentStorageHandler = NULL;
367 OCPersistentStorage* SRMGetPersistentStorageHandler()
369 return gPersistentStorageHandler;
372 OCStackResult SRMInitSecureResources()
374 // TODO: temporarily returning OC_STACK_OK every time until default
375 // behavior (for when SVR DB is missing) is settled.
376 InitSecureResources();
377 OCStackResult ret = OC_STACK_OK;
378 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
379 if (CA_STATUS_OK != CAregisterPskCredentialsHandler(GetDtlsPskCredentials))
381 OIC_LOG(ERROR, TAG, "Failed to revert TLS credential handler.");
382 ret = OC_STACK_ERROR;
384 CAregisterPkixInfoHandler(GetPkixInfo);
385 CAregisterGetCredentialTypesHandler(InitCipherSuiteList);
386 #endif // __WITH_DTLS__ or __WITH_TLS__
390 void SRMDeInitSecureResources()
392 DestroySecureResources();
395 OCStackResult SRMInitPolicyEngine()
397 return InitPolicyEngine(&g_policyEngineContext);
400 void SRMDeInitPolicyEngine()
402 DeInitPolicyEngine(&g_policyEngineContext);
405 bool SRMIsSecurityResourceURI(const char* uri)
412 const char *rsrcs[] = {
420 OIC_RSRC_DPAIRING_URI,
422 OC_RSRVD_PROV_CRL_URL
425 // Remove query from Uri for resource string comparison
426 size_t uriLen = strlen(uri);
427 char *query = strchr (uri, '?');
430 uriLen = query - uri;
433 for (size_t i = 0; i < sizeof(rsrcs)/sizeof(rsrcs[0]); i++)
435 size_t svrLen = strlen(rsrcs[i]);
437 if ((uriLen == svrLen) &&
438 (strncmp(uri, rsrcs[i], svrLen) == 0))
448 * Check whether persistent storage is valid
449 * @return OC_STACK_OK if valid, other errors otherwise;
451 OCStackResult CheckPersistentStorage(OCPersistentStorage* ps)
453 OIC_LOG_V(INFO, TAG, "In %s", __func__);
456 OCStackResult ret = OC_STACK_SVR_DB_NOT_EXIST;
457 OicSecDoxm_t* doxm = NULL;
458 OicSecPstat_t* pstat = NULL;
459 uint8_t *data = NULL;
464 OIC_LOG(ERROR, TAG, "NULL PersistentStorage Parameter");
465 ret = OC_STACK_INVALID_PARAM;
469 // Check whether the DB file exists
470 fp = ps->open(SVR_DB_DAT_FILE_NAME, "r+b");
473 OIC_LOG(ERROR, TAG, "DB file cannot be opened");
474 ret = OC_STACK_SVR_DB_NOT_EXIST;
475 SetPSStatus(PS_OPEN_FAIL);
480 OIC_LOG(INFO, TAG, "Checking doxm resource...");
481 //Check DOXM resource
482 ret = GetSecureVirtualDatabaseFromPS2(ps, OIC_JSON_DOXM_NAME, &data, &size);
483 // If database read failed
484 if (OC_STACK_OK != ret)
486 OIC_LOG (ERROR, TAG, "Can not find the DOXM Resource in SVR DB.");
487 ret = OC_STACK_INCONSISTENT_DB;
488 SetPSStatus(PS_PARSE_FAIL);
491 if (data && 0 < size)
493 // Read DOXM resource from PS
494 ret = CBORPayloadToDoxm(data, size, &doxm);
495 if (OC_STACK_OK != ret)
497 OIC_LOG_V(ERROR, TAG, "Failed to Convert CBOR to Doxm bin : %d", ret);
498 ret = OC_STACK_INCONSISTENT_DB;
499 SetPSStatus(PS_PARSE_FAIL);
505 ret = OC_STACK_INCONSISTENT_DB;
506 SetPSStatus(PS_PARSE_FAIL);
515 OIC_LOG(INFO, TAG, "Checking pstat resource...");
516 //Check PSTAT resource
517 ret = GetSecureVirtualDatabaseFromPS2(ps, OIC_JSON_PSTAT_NAME, &data, &size);
518 // If database read failed
519 if (OC_STACK_OK != ret)
521 OIC_LOG (ERROR, TAG, "Can not find the PSTAT Resource in SVR DB.");
522 ret = OC_STACK_INCONSISTENT_DB;
523 SetPSStatus(PS_PARSE_FAIL);
526 if (data && 0 < size)
528 // Read ACL resource from PS
529 ret = CBORPayloadToPstat(data, size, &pstat);
530 if (OC_STACK_OK != ret)
532 OIC_LOG_V(ERROR, TAG, "Failed to Convert CBOR to PSTAT bin : %d", ret);
533 ret = OC_STACK_INCONSISTENT_DB;
534 SetPSStatus(PS_PARSE_FAIL);
540 ret = OC_STACK_INCONSISTENT_DB;
541 SetPSStatus(PS_PARSE_FAIL);
550 SetPSStatus(PS_NORMAL);
553 OIC_LOG(INFO, TAG, "All Secure Virtual Resources are fine.");
562 DeleteDoxmBinData(doxm);
566 DeletePstatBinData(pstat);
569 OIC_LOG_V(INFO, TAG, "Out %s", __func__);
575 * Get the Secure Virtual Resource (SVR) type from the URI.
576 * @param uri [IN] Pointer to URI in question.
577 * @return The OicSecSvrType_t of the URI passed (note: if not a Secure Virtual
578 Resource, e.g. /a/light, will return "NOT_A_SVR_TYPE" enum value)
580 static const char URI_QUERY_CHAR = '?';
581 OicSecSvrType_t GetSvrTypeFromUri(const char* uri)
585 return NOT_A_SVR_RESOURCE;
588 // Remove query from Uri for resource string comparison
589 size_t uriLen = strlen(uri);
590 char *query = strchr (uri, URI_QUERY_CHAR);
593 uriLen = query - uri;
598 svrLen = strlen(OIC_RSRC_ACL_URI);
601 if(0 == strncmp(uri, OIC_RSRC_ACL_URI, svrLen))
603 return OIC_R_ACL_TYPE;
607 svrLen = strlen(OIC_RSRC_AMACL_URI);
610 if(0 == strncmp(uri, OIC_RSRC_AMACL_URI, svrLen))
612 return OIC_R_AMACL_TYPE;
616 svrLen = strlen(OIC_RSRC_CRED_URI);
619 if(0 == strncmp(uri, OIC_RSRC_CRED_URI, svrLen))
621 return OIC_R_CRED_TYPE;
625 svrLen = strlen(OIC_RSRC_CRL_URI);
628 if(0 == strncmp(uri, OIC_RSRC_CRL_URI, svrLen))
630 return OIC_R_CRL_TYPE;
634 svrLen = strlen(OIC_RSRC_DOXM_URI);
637 if(0 == strncmp(uri, OIC_RSRC_DOXM_URI, svrLen))
639 return OIC_R_DOXM_TYPE;
643 svrLen = strlen(OIC_RSRC_DPAIRING_URI);
646 if(0 == strncmp(uri, OIC_RSRC_DPAIRING_URI, svrLen))
648 return OIC_R_DPAIRING_TYPE;
652 svrLen = strlen(OIC_RSRC_PCONF_URI);
655 if(0 == strncmp(uri, OIC_RSRC_PCONF_URI, svrLen))
657 return OIC_R_PCONF_TYPE;
661 svrLen = strlen(OIC_RSRC_PSTAT_URI);
664 if(0 == strncmp(uri, OIC_RSRC_PSTAT_URI, svrLen))
666 return OIC_R_PSTAT_TYPE;
670 svrLen = strlen(OIC_RSRC_SACL_URI);
673 if(0 == strncmp(uri, OIC_RSRC_SACL_URI, svrLen))
675 return OIC_R_SACL_TYPE;
679 return NOT_A_SVR_RESOURCE;