[IOT-2461] Fix acl2 reverting
[iotivity.git] / resource / csdk / security / src / policyengine.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 #include <string.h>
21 #include <assert.h>
22
23 #include "utlist.h"
24 #include "oic_malloc.h"
25 #include "ocrandom.h"
26 #include "policyengine.h"
27 #include "resourcemanager.h"
28 #include "securevirtualresourcetypes.h"
29 #include "srmresourcestrings.h"
30 #include "logger.h"
31 #include "aclresource.h"
32 #include "srmutility.h"
33 #include "doxmresource.h"
34 #include "iotvticalendar.h"
35 #include "pstatresource.h"
36 #include "dpairingresource.h"
37 #include "pconfresource.h"
38 #include "amaclresource.h"
39 #include "credresource.h"
40 #include "rolesresource.h"
41 #include "deviceonboardingstate.h"
42
43 #define TAG "OIC_SRM_PE"
44
45 uint16_t GetPermissionFromCAMethod_t(const CAMethod_t method)
46 {
47     uint16_t perm = 0;
48     switch (method)
49     {
50         case CA_GET:
51             perm = (uint16_t)PERMISSION_READ;
52             break;
53         case CA_POST: // Treat all POST as Write (Update) because
54                       // we don't know if resource exists yet.
55                       // This will be addressed in IoTivity impl of OCF 1.0
56             perm = (uint16_t)PERMISSION_WRITE;
57             break;
58         case CA_PUT: // Per convention, OIC/OCF uses PUT only for Create,
59                      // never for Update.
60             perm = (uint16_t)PERMISSION_CREATE;
61             break;
62         case CA_DELETE:
63             perm = (uint16_t)PERMISSION_DELETE;
64             break;
65         default: // if not recognized, must assume requesting full control
66             perm = (uint16_t)PERMISSION_FULL_CONTROL;
67             break;
68     }
69
70     OIC_LOG_V(INFO, TAG, "%s: CA method %d requires permission %#x",
71         __func__, method, (uint32_t)perm);
72     return perm;
73 }
74
75 /**
76  * Compare the request's subject to DevOwner.
77  *
78  * @return true if context->subjectId == GetDoxmDevOwner(), else false.
79  */
80 static bool IsRequestFromDevOwner(SRMRequestContext_t *context)
81 {
82     bool retVal = false;
83     OicSecDoxm_t* doxm = NULL;
84
85     if (NULL == context)
86     {
87         return false;
88     }
89
90     if (IsNilUuid(&context->subjectUuid))
91     {
92         // Nil subject is never devOwner
93         retVal = false;
94         goto exit;
95     }
96
97     doxm = (OicSecDoxm_t*) GetDoxmResourceData();
98     if (doxm)
99     {
100         retVal = UuidCmp(&doxm->owner, &context->subjectUuid);
101         if (!retVal)
102         {
103             OIC_LOG(DEBUG, TAG, "Owner UUID  :");
104             OIC_LOG_BUFFER(DEBUG, TAG, (const uint8_t *)&doxm->owner.id, sizeof(OicUuid_t));
105             OIC_LOG(DEBUG, TAG, "Request UUID:");
106             OIC_LOG_BUFFER(DEBUG, TAG, (const uint8_t *)&context->subjectUuid.id, sizeof(OicUuid_t));
107         }
108     }
109 exit:
110     OIC_LOG_V(DEBUG, TAG, "%s: request was %sreceived from device owner",
111             __func__, retVal ? "" : "NOT ");
112     return retVal;
113 }
114
115 /**
116  * Check if the request has been received from a session used for Ownership Transfer.
117  *
118  * @return true if the CA_SECURE_ENDPOINT_ATTRIBUTE_ADMINISTRATOR bit is set, else false.
119  */
120 static bool IsRequestFromOwnershipTransferSession(SRMRequestContext_t *context)
121 {
122     bool retVal = false;
123
124 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
125     //Ownership Transfer sessions are allowed to bypass SVR ACEs, while this
126     //Device is not ready for normal operation yet.
127     if ((NULL != context) && (NULL != context->endPoint))
128     {
129         uint32_t allAttributes;
130         if (CAGetSecureEndpointAttributes(context->endPoint, &allAttributes) &&
131             (allAttributes & CA_SECURE_ENDPOINT_ATTRIBUTE_ADMINISTRATOR))
132         {
133             retVal = true;
134         }
135
136         OIC_LOG_V(DEBUG, TAG, "%s: request was %sreceived from Ownership Transfer session",
137             __func__, retVal ? "" : "NOT ");
138     }
139 #else
140     OC_UNUSED(context);
141 #endif
142
143     return retVal;
144 }
145
146 #ifdef MULTIPLE_OWNER
147 /**
148  * Compare the request's subject to SubOwner.
149  *
150  * @return true if context->subjectId exist subowner list, else false.
151  */
152 static bool IsRequestFromSubOwner(SRMRequestContext_t *context)
153 {
154     bool retVal = false;
155
156     if (IsNilUuid(&context->subjectUuid))
157     {
158         // Nil subject is never subOwner
159         retVal = false;
160         goto exit;
161     }
162
163     if (NULL != context)
164     {
165         retVal = IsSubOwner(&context->subjectUuid);
166     }
167
168 exit:
169     OIC_LOG_V(INFO, TAG, "%s: returning %s", __func__, retVal ? "true" : "false");
170     return retVal;
171 }
172
173 /**
174  * Verify the SubOwner's request.
175  *
176  * @return true if request is valid, else false.
177  */
178 static bool IsValidRequestFromSubOwner(SRMRequestContext_t *context)
179 {
180     bool isValidRequest = false;
181
182     if(NULL == context)
183     {
184         return isValidRequest;
185     }
186
187     switch(context->resourceType)
188     {
189         case OIC_R_DOXM_TYPE:
190             //SubOwner has READ permission only for DOXM
191             if(PERMISSION_READ == context->requestedPermission)
192             {
193                 isValidRequest = true;
194             }
195             break;
196         case OIC_R_PSTAT_TYPE:
197             //SubOwner has full permsion for PSTAT
198             isValidRequest = true;
199             break;
200         case OIC_R_CRED_TYPE:
201             //SubOwner can only access the credential which is registered as the eowner.
202             isValidRequest = IsValidCredentialAccessForSubOwner(&context->subjectUuid,
203              context->payload, context->payloadSize);
204             break;
205         case OIC_R_ACL_TYPE:
206             //SubOwner can only access the ACL which is registered as the eowner.
207             isValidRequest = IsValidAclAccessForSubOwner(&context->subjectUuid,
208                 context->payload, context->payloadSize);
209             break;
210         default:
211             //SubOwner has full permission for all resource except the security resource
212             isValidRequest = true;
213             break;
214     }
215
216     OIC_LOG_V(INFO, TAG, "%s: returning %s", __func__, isValidRequest ? "true" : "false");
217     return isValidRequest;
218 }
219 #endif //MULTIPLE_OWNER
220
221 static GetSvrRownerId_t GetSvrRownerId[OIC_SEC_SVR_TYPE_COUNT + 1] = {
222     NULL,
223     GetAclRownerId,
224     NULL,               // amacl's rowneruuid has been removed from the OCF 1.0 Security spec.
225     GetCredRownerId,
226     NULL,               // crl doesn't have rowneruuid.
227     GetDoxmRownerId,
228     GetDpairingRownerId,
229     GetPconfRownerId,
230     GetPstatRownerId,
231     NULL,               // sacl is not implemented yet.
232     NULL,               // svc has been removed from the OCF 1.0 Security spec.
233     NULL,               // csr
234     GetAclRownerId,     // acl2
235     NULL                // roles
236 };
237
238 /**
239  * Compare the request's subject to resource.ROwner.
240  *
241  * @return true if context->subjectId equals SVR rowner id, else return false
242  */
243 bool IsRequestFromResourceOwner(SRMRequestContext_t *context)
244 {
245     bool retVal = false;
246     OicUuid_t resourceOwner;
247
248     if (NULL == context)
249     {
250         retVal = false;
251         goto exit;
252     }
253
254     if (SUBJECT_ID_TYPE_UUID != context->subjectIdType)
255     {
256         OIC_LOG_V(DEBUG, TAG, "%s: Non-UUID subject type cannot be rowner.", __func__);
257         retVal = false;
258         goto exit;
259     }
260
261     if (IsNilUuid(&context->subjectUuid))
262     {
263         // Nil subject is never rOwner
264         OIC_LOG_V(DEBUG, TAG, "%s: Nil UUID cannot be rowner.", __func__);
265         retVal = false;
266         goto exit;
267     }
268
269     if((OIC_R_ACL_TYPE <= context->resourceType) && \
270         (OIC_SEC_SVR_TYPE_COUNT > context->resourceType))
271     {
272         GetSvrRownerId_t getRownerId = NULL;
273         OCStackResult getRownerResult = OC_STACK_ERROR;
274
275         getRownerId = GetSvrRownerId[(int)context->resourceType];
276
277         if (NULL != getRownerId)
278         {
279             getRownerResult = getRownerId(&resourceOwner);
280         }
281
282 #ifndef NDEBUG // if debug build, log the IDs being used for matching rowner
283         char strUuid[UUID_STRING_SIZE] = "UUID_ERROR";
284         if (OCConvertUuidToString(context->subjectUuid.id, strUuid))
285         {
286             OIC_LOG_V(DEBUG, TAG, "context->subjectUuid for request: %s.", strUuid);
287         }
288         else
289         {
290             OIC_LOG(ERROR, TAG, "failed to convert context->subjectUuid to str.");
291         }
292         if (OCConvertUuidToString(resourceOwner.id, strUuid))
293         {
294             OIC_LOG_V(DEBUG, TAG, "rowneruuid for requested SVR: %s.", strUuid);
295         }
296         else
297         {
298             OIC_LOG(ERROR, TAG, "failed to convert rowneruuid to str.");
299         }
300 #endif
301
302         if(OC_STACK_OK == getRownerResult)
303         {
304             retVal = UuidCmp(&context->subjectUuid, &resourceOwner);
305         }
306     }
307 exit:
308     OIC_LOG_V(INFO, TAG, "%s: returning %s", __func__, retVal ? "true" : "false");
309     return retVal;
310 }
311
312 /**
313  * Bitwise check to see if 'permission' contains 'request'.
314  *
315  * @param permission is the allowed CRUDN permission.
316  * @param request is the CRUDN permission being requested.
317  *
318  * @return true if 'permission' bits include all 'request' bits.
319  */
320 INLINE_API bool IsPermissionAllowingRequest(const uint16_t permission,
321     const uint16_t request)
322 {
323     bool allowed = (request == (request & permission));
324
325     OIC_LOG_V(INFO, TAG, "%s: ACE allows permission %#x, "
326         "requested permission %#x -> allowed = %u", __func__,
327         (uint32_t)permission, (uint32_t)request, (uint32_t)allowed);
328
329     return allowed;
330 }
331
332 /**
333  * Compare the passed subject to the wildcard (aka anonymous) subjectId.
334  *
335  * @return true if 'subject' is the wildcard, false if it is not.
336  */
337 INLINE_API bool IsWildCardSubject(OicUuid_t *subject)
338 {
339     if(NULL == subject)
340     {
341         return false;
342     }
343
344     // Because always comparing to string literal, use strcmp()
345     if(0 == memcmp(subject, &WILDCARD_SUBJECT_ID, sizeof(OicUuid_t)))
346     {
347         return true;
348     }
349     else
350     {
351         return false;
352     }
353 }
354
355 /**
356  * Check whether 'resource' is getting accessed within the valid time period.
357  *
358  * @param acl is the ACL to check.
359  *
360  * @return true if access is within valid time period or if the period or recurrence is not present.
361  * false if period and recurrence present and the access is not within valid time period.
362  */
363 static bool IsAccessWithinValidTime(const OicSecAce_t *ace)
364 {
365 #ifndef WITH_ARDUINO //Period & Recurrence not supported on Arduino due
366     //lack of absolute time
367     if (NULL== ace || NULL == ace->validities)
368     {
369         return true;
370     }
371
372     //periods & recurrences rules are paired.
373     if (NULL == ace->validities->recurrences)
374     {
375         return false;
376     }
377
378     OicSecValidity_t* validity =  NULL;
379     LL_FOREACH(ace->validities, validity)
380     {
381         for(size_t i = 0; i < validity->recurrenceLen; i++)
382         {
383             if (IOTVTICAL_VALID_ACCESS == IsRequestWithinValidTime(validity->period,
384                 validity->recurrences[i]))
385             {
386                 OIC_LOG(INFO, TAG, "Access request is in allowed time period");
387                 return true;
388             }
389         }
390     }
391     OIC_LOG(ERROR, TAG, "Access request is in invalid time period");
392     return false;
393
394 #else
395     return true;
396 #endif
397 }
398
399 /**
400  * Check whether 'resource' is in the passed ACE.
401  *
402  * @param[in] context Context->resourceUri contains the Resource being checked,
403  *                    as well as the discoverability of the Resource.
404  * @param[in] ace The ACE to check.
405  *
406  * @return true if match found, otherwise false.
407  */
408 static bool IsResourceInAce(SRMRequestContext_t *context, const OicSecAce_t *ace)
409 {
410     if (NULL == context || NULL == ace)
411     {
412         return false;
413     }
414
415     OicSecRsrc_t* rsrc = NULL;
416     LL_FOREACH(ace->resources, rsrc)
417     {
418         if (NULL == rsrc->href)
419         {
420             if (NO_WILDCARD != rsrc->wildcard)
421             {
422                 if ((ALL_RESOURCES == rsrc->wildcard) ||
423                     (ALL_DISCOVERABLE == rsrc->wildcard &&
424                         DISCOVERABLE_TRUE == context->discoverable) ||
425                     (ALL_NON_DISCOVERABLE == rsrc->wildcard &&
426                         DISCOVERABLE_FALSE == context->discoverable))
427                 {
428                     OIC_LOG_V(DEBUG, TAG, "%s: found wc type %d matching resource.",
429                         __func__, rsrc->wildcard);
430                     return true;
431                 }
432             }
433         }
434         else if (0 == strcmp(context->resourceUri, rsrc->href) ||
435                  0 == strcmp(WILDCARD_RESOURCE_URI, rsrc->href))
436         {
437             OIC_LOG_V(DEBUG, TAG, "%s: found href %s matching resource.",
438                         __func__, rsrc->href);
439             return true;
440         }
441     }
442     return false;
443 }
444
445 static void ProcessMatchingACE(SRMRequestContext_t *context, const OicSecAce_t *currentAce)
446 {
447     // Found the subject, so how about resource?
448     OIC_LOG_V(DEBUG, TAG, "%s: found ACE matching subject.", __func__);
449
450     // Subject was found, so err changes to Rsrc not found for now.
451     context->responseVal = ACCESS_DENIED_RESOURCE_NOT_FOUND;
452     OIC_LOG_V(DEBUG, TAG, "%s: Searching for resource...", __func__);
453     if (IsResourceInAce(context, currentAce))
454     {
455         OIC_LOG_V(INFO, TAG, "%s: found matching resource in ACE.", __func__);
456
457         // Found the resource, so it's down to valid period & permission.
458         context->responseVal = ACCESS_DENIED_INVALID_PERIOD;
459         if (IsAccessWithinValidTime(currentAce))
460         {
461             context->responseVal = ACCESS_DENIED_INSUFFICIENT_PERMISSION;
462             if (IsPermissionAllowingRequest(currentAce->permission,
463                 context->requestedPermission))
464             {
465                 context->responseVal = ACCESS_GRANTED;
466             }
467         }
468     }
469 }
470
471 /**
472  * Search for an ACE that matches the Resource URI, by conntype, subjectuuid, or roles.
473  * For each matching ACE, check whether it grants permission.
474  * If any ACE grants permission, set responseVal to ACCESS_GRANTED.
475  */
476 static void ProcessAccessRequest(SRMRequestContext_t *context)
477 {
478     if (NULL == context)
479     {
480         OIC_LOG(ERROR, TAG, "ProcessAccessRequest(): context is NULL, returning.");
481         return;
482     }
483
484     OIC_LOG_V(DEBUG, TAG, "Entering %s(%s)", __func__, context->resourceUri);
485
486     const OicSecAce_t *currentAce = NULL;
487     OicSecAce_t *aceSavePtr = NULL;
488
489     // Start out assuming subject not found.
490     context->responseVal = ACCESS_DENIED_SUBJECT_NOT_FOUND;
491
492     // First, check for a conntype ACE that matches.
493     OicSecConntype_t conntype;
494     if (context->secureChannel)
495     {
496         conntype = AUTH_CRYPT;
497     }
498     else
499     {
500         conntype = ANON_CLEAR;
501     }
502     do
503     {
504         currentAce = GetACLResourceDataByConntype(conntype, &aceSavePtr);
505
506         if (NULL != currentAce)
507         {
508             OIC_LOG_V(DEBUG, TAG, "%s: found conntype %s match; processing for access.",
509                 __func__, (AUTH_CRYPT == conntype?"auth-crypt":"anon-clear"));
510             ProcessMatchingACE(context, currentAce);
511         }
512         else
513         {
514             OIC_LOG_V(INFO, TAG, "%s:no ACL found matching conntype %s for resource %s",
515                 __func__, (AUTH_CRYPT == conntype?"auth-crypt":"anon-clear"), context->resourceUri);
516         }
517     } while ((NULL != currentAce) && !IsAccessGranted(context->responseVal));
518
519     // If not granted via conntype, try Subject-based match.
520     if (!IsAccessGranted(context->responseVal))
521     {
522         currentAce = NULL;
523         aceSavePtr = NULL;
524         do
525         {
526             currentAce = GetACLResourceData(&context->subjectUuid, &aceSavePtr);
527
528             if (NULL != currentAce)
529             {
530                 ProcessMatchingACE(context, currentAce);
531             }
532             else
533             {
534                 OIC_LOG_V(INFO, TAG, "%s:no ACL found matching subject for resource %s",
535                     __func__, context->resourceUri);
536             }
537         } while ((NULL != currentAce) && !IsAccessGranted(context->responseVal));
538     }
539
540 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
541     // If no subject ACE granted access, try role ACEs.
542     if (!IsAccessGranted(context->responseVal))
543     {
544         currentAce = NULL;
545         aceSavePtr = NULL;
546         OicSecRole_t *roles = NULL;
547         size_t roleCount = 0;
548         OCStackResult res = GetEndpointRoles(context->endPoint, &roles, &roleCount);
549         if (OC_STACK_OK != res)
550         {
551             OIC_LOG_V(ERROR, TAG, "Error getting asserted roles for endpoint: %d", res);
552         }
553         else
554         {
555             OIC_LOG_V(DEBUG, TAG, "Found %u asserted roles for endpoint", (unsigned int) roleCount);
556             do
557             {
558                 currentAce = GetACLResourceDataByRoles(roles, roleCount, &aceSavePtr);
559                 if (NULL != currentAce)
560                 {
561                     ProcessMatchingACE(context, currentAce);
562                 }
563                 else
564                 {
565                     OIC_LOG_V(INFO, TAG, "%s:no ACL found matching roles for resource %s",
566                         __func__, context->resourceUri);
567                 }
568             } while ((NULL != currentAce) && !IsAccessGranted(context->responseVal));
569
570             OICFree(roles);
571         }
572     }
573 #endif /* defined(__WITH_DTLS__) || defined(__WITH_TLS__) */
574
575     OIC_LOG_V(INFO, TAG, "%s: returning with responseVal = %s", __func__,
576         IsAccessGranted(context->responseVal) ? "ACCESS_GRANTED" : "ACCESS_DENIED");
577     return;
578 }
579
580 void CheckPermission(SRMRequestContext_t *context)
581 {
582     assert(NULL != context);
583     assert(0 != context->requestedPermission);
584     assert(0 == (context->requestedPermission & ~PERMISSION_FULL_CONTROL));
585
586     context->responseVal = ACCESS_DENIED_POLICY_ENGINE_ERROR;
587
588     // Before doing any ACL processing, check if request is a) coming
589     // from DevOwner AND b) the device is in Ready for OTM or SRESET state
590     // AND c) the request is for a SVR resource.
591     // If all 3 conditions are met, grant request.
592     OicSecDostype_t dos;
593     VERIFY_SUCCESS(TAG, OC_STACK_OK == GetDos(&dos), ERROR);
594
595     // Test for implicit access.
596     if (IsRequestFromDevOwner(context) &&
597         ((DOS_RFOTM == dos.state) || (DOS_SRESET == dos.state)) &&
598         (NOT_A_SVR_RESOURCE != context->resourceType))
599     {
600         OIC_LOG_V(INFO, TAG, "%s: granting implicit access to device owner", __func__);
601         context->responseVal = ACCESS_GRANTED;
602     }
603     // If not granted via DevOwner status and not a subowner,
604     // then check if request is for a SVR and coming from rowner.
605     else if (IsRequestFromResourceOwner(context))
606     {
607         OIC_LOG_V(INFO, TAG, "%s: granting implicit access to resource owner", __func__);
608         context->responseVal = ACCESS_GRANTED;
609     }
610 #ifdef MULTIPLE_OWNER
611     // Then check if request from SubOwner.
612     else if (IsRequestFromSubOwner(context))
613     {
614         if (IsValidRequestFromSubOwner(context))
615         {
616             OIC_LOG_V(INFO, TAG, "%s: granting implicit access to device sub-owner", __func__);
617             context->responseVal = ACCESS_GRANTED;
618         }
619     }
620 #endif //MULTIPLE_OWNER
621     else if ((DOS_RFNOP != dos.state) &&
622              (NOT_A_SVR_RESOURCE != context->resourceType) &&
623              IsRequestFromOwnershipTransferSession(context))
624     {
625         OIC_LOG_V(INFO, TAG, "%s: granting implicit access to OT session request", __func__);
626         context->responseVal = ACCESS_GRANTED;
627     }
628     // Else request is a "normal" request that must be tested against ACL.
629     else
630     {
631         ProcessAccessRequest(context);
632     }
633
634 exit:
635     return;
636 }