6b164cecc0659f23ff2a777c481f9472ac00c28b
[iotivity.git] / resource / csdk / security / src / secureresourcemanager.c
1 //******************************************************************
2 //
3 // Copyright 2015 Intel Mobile Communications GmbH 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 <string.h>
22 #include "ocstack.h"
23 #include "logger.h"
24 #include "cainterface.h"
25 #include "resourcemanager.h"
26 #include "credresource.h"
27 #include "policyengine.h"
28 #include "srmutility.h"
29 #include "oic_string.h"
30 #include "oic_malloc.h"
31 #include "securevirtualresourcetypes.h"
32 #include "secureresourcemanager.h"
33 #include "srmresourcestrings.h"
34 #include "ocresourcehandler.h"
35
36 #if defined( __WITH_TLS__) || defined(__WITH_DTLS__)
37 #include "pkix_interface.h"
38 #endif //__WITH_TLS__ or __WITH_DTLS__
39 #define TAG  "OIC_SRM"
40
41 //Request Callback handler
42 static CARequestCallback gRequestHandler = NULL;
43 //Response Callback handler
44 static CAResponseCallback gResponseHandler = NULL;
45 //Error Callback handler
46 static CAErrorCallback gErrorHandler = NULL;
47 //Provisioning response callback
48 static SPResponseCallback gSPResponseHandler = NULL;
49
50 /**
51  * A single global Request context will suffice as long
52  * as SRM is single-threaded.
53  */
54 SRMRequestContext_t g_requestContext;
55
56 /**
57  * Function to register provisoning API's response callback.
58  * @param respHandler response handler callback.
59  */
60 void SRMRegisterProvisioningResponseHandler(SPResponseCallback respHandler)
61 {
62     gSPResponseHandler = respHandler;
63 }
64
65 void SetRequestedResourceType(SRMRequestContext_t *context)
66 {
67     context->resourceType = GetSvrTypeFromUri(context->resourceUri);
68 }
69
70 // Send the response (context->responseInfo) to the requester
71 // (context->endPoint).
72 static void SRMSendResponse(SRMRequestContext_t *context)
73 {
74     if (NULL != context
75         && NULL != context->requestInfo
76         && NULL != context->endPoint)
77     {
78
79         if (CA_STATUS_OK == CASendResponse(context->endPoint,
80             &(context->responseInfo)))
81         {
82             OIC_LOG(DEBUG, TAG, "SRM response sent.");
83             context->responseSent = true;
84         }
85         else
86         {
87             OIC_LOG(ERROR, TAG, "SRM response failed.");
88         }
89     }
90     else
91     {
92         OIC_LOG_V(ERROR, TAG, "%s : NULL Parameter(s)",__func__);
93     }
94
95     return;
96 }
97
98 // Based on the context->responseVal, either call the entity handler for the
99 // request (which must send the response), or send an ACCESS_DENIED response.
100 void SRMGenerateResponse(SRMRequestContext_t *context)
101 {
102     OIC_LOG_V(INFO, TAG, "%s : entering function.", __func__);
103
104     // If Access Granted, validate parameters and then pass request
105     // on to resource endpoint.
106     if (IsAccessGranted(context->responseVal))
107     {
108         if(NULL != gRequestHandler
109             && NULL != context->endPoint
110             && NULL != context->requestInfo)
111         {
112             OIC_LOG_V(INFO, TAG, "%s : Access granted, passing req to endpoint.",
113              __func__);
114             gRequestHandler(context->endPoint, context->requestInfo);
115             context->responseSent = true; // SRM counts on the endpoint to send
116                                           // a response.
117         }
118         else // error condition; log relevant msg then send DENIED response
119         {
120             OIC_LOG_V(ERROR, TAG, "%s : Null values in context.", __func__);
121             context->responseVal = ACCESS_DENIED_POLICY_ENGINE_ERROR;
122             context->responseInfo.result = CA_INTERNAL_SERVER_ERROR;
123             SRMSendResponse(context);
124         }
125     }
126     else // Access Denied
127     {
128         OIC_LOG_V(INFO, TAG, "%s : Access Denied; sending CA_UNAUTHORIZED_REQ.",
129          __func__);
130         // TODO: in future version, differentiate between types of DENIED.
131         // See JIRA issue 1796 (https://jira.iotivity.org/browse/IOT-1796)
132         context->responseInfo.result = CA_UNAUTHORIZED_REQ;
133         SRMSendResponse(context);
134     }
135     return;
136 }
137
138 // Set the value of context->resourceUri, based on the context->requestInfo.
139 void SetResourceUriAndType(SRMRequestContext_t *context)
140 {
141     char *uri = strstr(context->requestInfo->info.resourceUri, "?");
142     size_t position = 0;
143
144     if (uri)
145     {
146         //Skip query and pass the resource uri
147         position = uri - context->requestInfo->info.resourceUri;
148     }
149     else
150     {
151         position = strlen(context->requestInfo->info.resourceUri);
152     }
153     if (MAX_URI_LENGTH < position  || 0 > position)
154     {
155         OIC_LOG(ERROR, TAG, "Incorrect URI length.");
156         return;
157     }
158     OICStrcpyPartial(context->resourceUri, MAX_URI_LENGTH + 1,
159         context->requestInfo->info.resourceUri, position);
160
161     // Set the resource type.
162     context->resourceType = GetSvrTypeFromUri(context->resourceUri);
163
164     return;
165 }
166
167 // Check if this request is asking to access a "sec" = true resource
168 // over an unsecure channel.  This type of request is forbidden with
169 // the exception of a few SVRs (see Security Specification).
170 void CheckRequestForSecResourceOverUnsecureChannel(SRMRequestContext_t *context)
171 {
172     OIC_LOG_V(DEBUG, TAG, "%s: secureChannel = %u, resourceType = %d, URI = %s",
173         __func__, (uint32_t)context->secureChannel,
174         context->resourceType, context->resourceUri);
175
176     // if request is over unsecure channel, check resource type
177     if(false == context->secureChannel)
178     {
179         OCResource *resPtr = FindResourceByUri(context->resourceUri);
180
181         // TODO: IOT-1843:
182         // Should a NULL return value from FindResourceByUri result in CA_FORBIDDEN_REQ?
183         if (NULL != resPtr)
184         {
185             OIC_LOG_V(DEBUG, TAG, "%s: OC_SECURE = %s",
186                 __func__, ((resPtr->resourceProperties) & OC_SECURE) ? "true" : "false");
187
188             // All vertical secure resources and SVR resources other than
189             // DOXM & PSTAT should reject requests over unsecure channel.
190             if ((((resPtr->resourceProperties) & OC_SECURE)
191                 && (context->resourceType == NOT_A_SVR_RESOURCE))
192                 || ((context->resourceType < OIC_SEC_SVR_TYPE_COUNT)
193                     && (context->resourceType != OIC_R_DOXM_TYPE)
194                     && (context->resourceType != OIC_R_PSTAT_TYPE)))
195             {
196                 // Reject all the requests over coap for secure resource.
197                 context->responseVal = ACCESS_DENIED_SEC_RESOURCE_OVER_UNSECURE_CHANNEL;
198                 context->responseInfo.result = CA_FORBIDDEN_REQ;
199                 SRMSendResponse(context);
200             }
201             else
202             {
203                 OIC_LOG_V(DEBUG, TAG, "%s: Allowing unsecured access", __func__);
204             }
205         }
206     }
207
208     return;
209 }
210
211 void ClearRequestContext(SRMRequestContext_t *context)
212 {
213     if (NULL == context)
214     {
215
216         OIC_LOG(ERROR, TAG, "Null context.");
217     }
218     else
219     {
220         // Clear context variables.
221         context->endPoint = NULL;
222         context->resourceType = OIC_RESOURCE_TYPE_ERROR;
223         memset(&context->resourceUri, 0, sizeof(context->resourceUri));
224         context->requestedPermission = PERMISSION_ERROR;
225         memset(&context->responseInfo, 0, sizeof(context->responseInfo));
226         context->responseSent = false;
227         context->responseVal = ACCESS_DENIED_POLICY_ENGINE_ERROR;
228         context->requestInfo = NULL;
229         context->secureChannel = false;
230         context->slowResponseSent = false;
231         context->subjectIdType = SUBJECT_ID_TYPE_ERROR;
232         memset(&context->subjectUuid, 0, sizeof(context->subjectUuid));
233 #ifdef MULTIPLE_OWNER
234         context->payload = NULL;
235         context->payloadSize = 0;
236 #endif //MULTIPLE_OWNER
237     }
238
239     return;
240 }
241
242 // Returns true iff Request arrived over secure channel
243 bool isRequestOverSecureChannel(SRMRequestContext_t *context)
244 {
245     OicUuid_t nullSubjectId = {.id = {0}};
246
247     // if flag set, return true
248     if(context->endPoint->flags & CA_SECURE)
249     {
250         return true;
251     }
252     // a null subject ID indicates CoAP, so if non-null, also return true
253     else if(memcmp(context->requestInfo->info.identity.id,
254         nullSubjectId.id, sizeof(context->requestInfo->info.identity.id)) != 0)
255     {
256         return true;
257     }
258
259     return false;
260 }
261
262 /**
263  * Entry point into SRM, called by lower layer to determine whether an incoming
264  * request should be GRANTED or DENIED.
265  *
266  * @param endPoint object from which the response is received.
267  * @param requestInfo contains information for the request.
268  */
269 void SRMRequestHandler(const CAEndpoint_t *endPoint, const CARequestInfo_t *requestInfo)
270 {
271     OIC_LOG(DEBUG, TAG, "Received request from remote device");
272
273     SRMRequestContext_t *ctx = &g_requestContext; // Always use our single ctx for now.
274
275     ClearRequestContext(ctx);
276
277     if (!endPoint || !requestInfo)
278     {
279         OIC_LOG(ERROR, TAG, "Invalid endPoint or requestInfo; can't process.");
280     }
281     else
282     {
283         ctx->endPoint = endPoint;
284         ctx->requestInfo = requestInfo;
285         ctx->requestedPermission = GetPermissionFromCAMethod_t(requestInfo->method);
286
287         // Copy the subjectID.
288         memcpy(ctx->subjectUuid.id,
289             requestInfo->info.identity.id, sizeof(ctx->subjectUuid.id));
290         ctx->subjectIdType = SUBJECT_ID_TYPE_UUID; // only supported type for now
291
292         // Set secure channel boolean.
293         ctx->secureChannel = isRequestOverSecureChannel(ctx);
294
295         // Set resource URI and type.
296         SetResourceUriAndType(ctx);
297
298         // Initialize responseInfo.
299         memcpy(&(ctx->responseInfo.info), &(requestInfo->info),
300             sizeof(ctx->responseInfo.info));
301         ctx->responseInfo.info.payload = NULL;
302         ctx->responseInfo.result = CA_INTERNAL_SERVER_ERROR;
303         ctx->responseInfo.info.dataType = CA_RESPONSE_DATA;
304
305         // Before consulting ACL, check if this is a forbidden request type.
306         CheckRequestForSecResourceOverUnsecureChannel(ctx);
307
308         // If DENIED response wasn't sent already, then it's time to check ACL.
309         if(false == ctx->responseSent)
310         {
311 #ifdef MULTIPLE_OWNER // TODO Samsung: please verify that these two calls belong
312                       // here inside this conditional statement.
313             // In case of ACL and CRED, The payload required to verify the payload.
314             // Payload information will be used for subowner's permission verification.
315             ctx->payload = (uint8_t*)requestInfo->info.payload;
316             ctx->payloadSize = requestInfo->info.payloadSize;
317 #endif //MULTIPLE_OWNER
318
319             OIC_LOG_V(DEBUG, TAG, "Processing request with uri, %s for method %d",
320                 ctx->requestInfo->info.resourceUri, ctx->requestInfo->method);
321             CheckPermission(ctx);
322             OIC_LOG_V(DEBUG, TAG, "Request for permission %d received responseVal %d.",
323                 ctx->requestedPermission, ctx->responseVal);
324
325             // Now that we have determined the correct response and set responseVal,
326             // we generate and send the response to the requester.
327             SRMGenerateResponse(ctx);
328         }
329     }
330
331     if(false == ctx->responseSent)
332     {
333         OIC_LOG(ERROR, TAG, "Exiting SRM without responding to requester!");
334     }
335
336     return;
337 }
338
339 /**
340  * Handle the response from the SRM.
341  *
342  * @param endPoint points to the remote endpoint.
343  * @param responseInfo contains response information from the endpoint.
344  */
345 void SRMResponseHandler(const CAEndpoint_t *endPoint, const CAResponseInfo_t *responseInfo)
346 {
347     OIC_LOG(DEBUG, TAG, "Received response from remote device");
348
349     // isProvResponse flag is to check whether response is catered by provisioning APIs or not.
350     // When token sent by CA response matches with token generated by provisioning request,
351     // gSPResponseHandler returns true and response is not sent to RI layer. In case
352     // gSPResponseHandler is null and isProvResponse is false response then the response is for
353     // RI layer.
354     bool isProvResponse = false;
355
356     if (gSPResponseHandler)
357     {
358         isProvResponse = gSPResponseHandler(endPoint, responseInfo);
359     }
360     if (!isProvResponse && gResponseHandler)
361     {
362         gResponseHandler(endPoint, responseInfo);
363     }
364 }
365
366 /**
367  * Handle the error from the SRM.
368  *
369  * @param endPoint is the remote endpoint.
370  * @param errorInfo contains error information from the endpoint.
371  */
372 void SRMErrorHandler(const CAEndpoint_t *endPoint, const CAErrorInfo_t *errorInfo)
373 {
374     OIC_LOG_V(INFO, TAG, "Received error from remote device with result, %d for request uri, %s",
375         errorInfo->result, errorInfo->info.resourceUri);
376     if (gErrorHandler)
377     {
378         gErrorHandler(endPoint, errorInfo);
379     }
380 }
381
382 OCStackResult SRMRegisterHandler(CARequestCallback reqHandler,
383     CAResponseCallback respHandler, CAErrorCallback errHandler)
384 {
385     OIC_LOG(DEBUG, TAG, "SRMRegisterHandler !!");
386     if( !reqHandler || !respHandler || !errHandler)
387     {
388         OIC_LOG(ERROR, TAG, "Callback handlers are invalid");
389         return OC_STACK_INVALID_PARAM;
390     }
391     gRequestHandler = reqHandler;
392     gResponseHandler = respHandler;
393     gErrorHandler = errHandler;
394
395
396 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
397     CARegisterHandler(SRMRequestHandler, SRMResponseHandler, SRMErrorHandler);
398 #else
399     CARegisterHandler(reqHandler, respHandler, errHandler);
400 #endif /* __WITH_DTLS__ */
401     return OC_STACK_OK;
402 }
403
404 OCStackResult SRMRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
405 {
406     OIC_LOG(DEBUG, TAG, "SRMRegisterPersistentStorageHandler !!");
407     return OCRegisterPersistentStorageHandler(persistentStorageHandler);
408 }
409
410 OCPersistentStorage* SRMGetPersistentStorageHandler()
411 {
412     return OCGetPersistentStorageHandler();
413 }
414
415 OCStackResult SRMInitSecureResources()
416 {
417     // TODO: temporarily returning OC_STACK_OK every time until default
418     // behavior (for when SVR DB is missing) is settled.
419     InitSecureResources();
420     OCStackResult ret = OC_STACK_OK;
421 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
422     if (CA_STATUS_OK != CAregisterPskCredentialsHandler(GetDtlsPskCredentials))
423     {
424         OIC_LOG(ERROR, TAG, "Failed to revert TLS credential handler.");
425         ret = OC_STACK_ERROR;
426     }
427     CAregisterPkixInfoHandler(GetPkixInfo);
428     CAregisterGetCredentialTypesHandler(InitCipherSuiteList);
429 #endif // __WITH_DTLS__ or __WITH_TLS__
430     return ret;
431 }
432
433 void SRMDeInitSecureResources()
434 {
435     DestroySecureResources();
436 }
437
438 bool SRMIsSecurityResourceURI(const char* uri)
439 {
440     if (!uri)
441     {
442         return false;
443     }
444
445 #ifdef _MSC_VER
446     // The strings below are const but they are also marked as extern so they cause warnings.
447 #pragma warning(push)
448 #pragma warning(disable:4204)
449 #endif
450     const char *rsrcs[] = {
451         OIC_RSRC_SVC_URI,
452         OIC_RSRC_AMACL_URI,
453         OIC_RSRC_CRL_URI,
454         OIC_RSRC_CRED_URI,
455         OIC_RSRC_ACL_URI,
456         OIC_RSRC_DOXM_URI,
457         OIC_RSRC_PSTAT_URI,
458         OIC_RSRC_PCONF_URI,
459         OIC_RSRC_DPAIRING_URI,
460         OIC_RSRC_VER_URI,
461         OC_RSRVD_PROV_CRL_URL
462     };
463
464 #ifdef _MSC_VER
465 #pragma warning(pop)
466 #endif
467
468     // Remove query from Uri for resource string comparison
469     size_t uriLen = strlen(uri);
470     char *query = strchr (uri, '?');
471     if (query)
472     {
473         uriLen = query - uri;
474     }
475
476     for (size_t i = 0; i < sizeof(rsrcs)/sizeof(rsrcs[0]); i++)
477     {
478         size_t svrLen = strlen(rsrcs[i]);
479
480         if ((uriLen == svrLen) &&
481             (strncmp(uri, rsrcs[i], svrLen) == 0))
482         {
483             return true;
484         }
485     }
486
487     return false;
488 }
489
490 /**
491  * Get the Secure Virtual Resource (SVR) type from the URI.
492  * @param   uri [IN] Pointer to URI in question.
493  * @return  The OicSecSvrType_t of the URI passed (note: if not a Secure Virtual
494             Resource, e.g. /a/light, will return "NOT_A_SVR_TYPE" enum value)
495  */
496 static const char URI_QUERY_CHAR = '?';
497 OicSecSvrType_t GetSvrTypeFromUri(const char* uri)
498 {
499     if (!uri)
500     {
501         return NOT_A_SVR_RESOURCE;
502     }
503
504     // Remove query from Uri for resource string comparison
505     size_t uriLen = strlen(uri);
506     char *query = strchr (uri, URI_QUERY_CHAR);
507     if (query)
508     {
509         uriLen = query - uri;
510     }
511
512     size_t svrLen = 0;
513
514     svrLen = strlen(OIC_RSRC_ACL_URI);
515     if(uriLen == svrLen)
516     {
517         if(0 == strncmp(uri, OIC_RSRC_ACL_URI, svrLen))
518         {
519             return OIC_R_ACL_TYPE;
520         }
521     }
522
523     svrLen = strlen(OIC_RSRC_AMACL_URI);
524     if(uriLen == svrLen)
525     {
526         if(0 == strncmp(uri, OIC_RSRC_AMACL_URI, svrLen))
527         {
528             return OIC_R_AMACL_TYPE;
529         }
530     }
531
532     svrLen = strlen(OIC_RSRC_CRED_URI);
533     if(uriLen == svrLen)
534     {
535         if(0 == strncmp(uri, OIC_RSRC_CRED_URI, svrLen))
536         {
537             return OIC_R_CRED_TYPE;
538         }
539     }
540
541     svrLen = strlen(OIC_RSRC_CRL_URI);
542     if(uriLen == svrLen)
543     {
544         if(0 == strncmp(uri, OIC_RSRC_CRL_URI, svrLen))
545         {
546             return OIC_R_CRL_TYPE;
547         }
548     }
549
550     svrLen = strlen(OIC_RSRC_DOXM_URI);
551     if(uriLen == svrLen)
552     {
553         if(0 == strncmp(uri, OIC_RSRC_DOXM_URI, svrLen))
554         {
555             return OIC_R_DOXM_TYPE;
556         }
557     }
558
559     svrLen = strlen(OIC_RSRC_DPAIRING_URI);
560     if(uriLen == svrLen)
561     {
562         if(0 == strncmp(uri, OIC_RSRC_DPAIRING_URI, svrLen))
563         {
564             return OIC_R_DPAIRING_TYPE;
565         }
566     }
567
568     svrLen = strlen(OIC_RSRC_PCONF_URI);
569     if(uriLen == svrLen)
570     {
571         if(0 == strncmp(uri, OIC_RSRC_PCONF_URI, svrLen))
572         {
573             return OIC_R_PCONF_TYPE;
574         }
575     }
576
577     svrLen = strlen(OIC_RSRC_PSTAT_URI);
578     if(uriLen == svrLen)
579     {
580         if(0 == strncmp(uri, OIC_RSRC_PSTAT_URI, svrLen))
581         {
582             return OIC_R_PSTAT_TYPE;
583         }
584     }
585
586     svrLen = strlen(OIC_RSRC_SVC_URI);
587     if(uriLen == svrLen)
588     {
589         if(0 == strncmp(uri, OIC_RSRC_SVC_URI, svrLen))
590         {
591             return OIC_R_SVC_TYPE;
592         }
593     }
594
595     svrLen = strlen(OIC_RSRC_SACL_URI);
596     if(uriLen == svrLen)
597     {
598         if(0 == strncmp(uri, OIC_RSRC_SACL_URI, svrLen))
599         {
600             return OIC_R_SACL_TYPE;
601         }
602     }
603
604     return NOT_A_SVR_RESOURCE;
605 }