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