779688c4deb4e2b4e43a004c323dd0df62d12a24
[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
22 #include "utlist.h"
23 #include "oic_malloc.h"
24 #include "policyengine.h"
25 #include "amsmgr.h"
26 #include "resourcemanager.h"
27 #include "securevirtualresourcetypes.h"
28 #include "srmresourcestrings.h"
29 #include "logger.h"
30 #include "aclresource.h"
31 #include "srmutility.h"
32 #include "doxmresource.h"
33 #include "iotvticalendar.h"
34 #include "pstatresource.h"
35 #include "dpairingresource.h"
36 #include "pconfresource.h"
37 #include "amaclresource.h"
38 #include "credresource.h"
39
40 #define TAG "OIC_SRM_PE"
41
42 uint16_t GetPermissionFromCAMethod_t(const CAMethod_t method)
43 {
44     uint16_t perm = 0;
45     switch (method)
46     {
47         case CA_GET:
48             perm = (uint16_t)PERMISSION_READ;
49             break;
50         case CA_POST: // Treat all POST as Write (Update) because
51                       // we don't know if resource exists yet.
52                       // This will be addressed in IoTivity impl of OCF 1.0
53             perm = (uint16_t)PERMISSION_WRITE;
54             break;
55         case CA_PUT: // Per convention, OIC/OCF uses PUT only for Create,
56                      // never for Update.
57             perm = (uint16_t)PERMISSION_CREATE;
58             break;
59         case CA_DELETE:
60             perm = (uint16_t)PERMISSION_DELETE;
61             break;
62         default: // if not recognized, must assume requesting full control
63             perm = (uint16_t)PERMISSION_FULL_CONTROL;
64             break;
65     }
66     return perm;
67 }
68
69 /**
70  * Compares two OicUuid_t structs.
71  *
72  * @return true if the two OicUuid_t structs are equal, else false.
73  */
74 static bool UuidCmp(OicUuid_t *firstId, OicUuid_t *secondId)
75 {
76     // TODO use VERIFY macros to check for null when they are merged.
77     if(NULL == firstId || NULL == secondId)
78     {
79         return false;
80     }
81     // Check empty uuid string
82     if('\0' == firstId->id[0] || '\0' == secondId->id[0])
83     {
84         return false;
85     }
86     for(int i = 0; i < UUID_LENGTH; i++)
87     {
88         if(firstId->id[i] != secondId->id[i])
89         {
90             return false;
91         }
92     }
93     return true;
94 }
95
96 void SetPolicyEngineState(PEContext_t *context, const PEState_t state)
97 {
98     if (NULL == context)
99     {
100         return;
101     }
102
103     // Clear stateful context variables.
104     memset(&context->subject, 0, sizeof(context->subject));
105     memset(&context->resource, 0, sizeof(context->resource));
106     context->permission = 0x0;
107     context->amsProcessing = false;
108     context->retVal = ACCESS_DENIED_POLICY_ENGINE_ERROR;
109
110     if (context->amsMgrContext)
111     {
112         if (context->amsMgrContext->requestInfo)
113         {
114             FreeCARequestInfo(context->amsMgrContext->requestInfo);
115         }
116         OICFree(context->amsMgrContext->endpoint);
117         memset(context->amsMgrContext, 0, sizeof(AmsMgrContext_t));
118     }
119
120     // Set state.
121     context->state = state;
122 }
123
124 /**
125  * Compare the request's subject to DevOwner.
126  *
127  * @return true if context->subjectId == GetDoxmDevOwner(), else false.
128  */
129 static bool IsRequestFromDevOwner(PEContext_t *context)
130 {
131     bool retVal = false;
132
133     if(NULL == context)
134     {
135         return retVal;
136     }
137
138     /*
139     if(OC_STACK_OK == GetDoxmDevOwnerId(&ownerid))
140     {
141         retVal = UuidCmp(&context->subject, &ownerid);
142     }
143     */
144
145     // TODO: Added as workaround for CTT
146     OicSecDoxm_t* doxm = (OicSecDoxm_t*) GetDoxmResourceData();
147     if (doxm)
148     {
149         retVal = UuidCmp(&doxm->owner, &context->subject);
150     }
151     return retVal;
152 }
153
154
155 #ifdef MULTIPLE_OWNER
156 /**
157  * Compare the request's subject to SubOwner.
158  *
159  * @return true if context->subjectId exist subowner list, else false.
160  */
161 static bool IsRequestFromSubOwner(PEContext_t *context)
162 {
163     bool retVal = false;
164
165     if(NULL == context)
166     {
167         return retVal;
168     }
169
170     if(IsSubOwner(&context->subject))
171     {
172         retVal = true;
173     }
174
175     if(true == retVal)
176     {
177         OIC_LOG(INFO, TAG, "PE.IsRequestFromSubOwner(): returning true");
178     }
179     else
180     {
181         OIC_LOG(INFO, TAG, "PE.IsRequestFromSubOwner(): returning false");
182     }
183
184     return retVal;
185 }
186
187
188 /**
189  * Verify the SubOwner's request.
190  *
191  * @return true if request is valid, else false.
192  */
193 static bool IsValidRequestFromSubOwner(PEContext_t *context)
194 {
195     bool isValidRequest = false;
196
197     if(NULL == context)
198     {
199         return isValidRequest;
200     }
201
202     switch(context->resourceType)
203     {
204         case OIC_R_DOXM_TYPE:
205             //SubOwner has READ permission only for DOXM
206             if(PERMISSION_READ == context->permission)
207             {
208                 isValidRequest = true;
209             }
210             break;
211         case OIC_R_PSTAT_TYPE:
212             //SubOwner has full permsion for PSTAT
213             isValidRequest = true;
214             break;
215         case OIC_R_CRED_TYPE:
216             //SubOwner can only access the credential which is registered as the eowner.
217             isValidRequest = IsValidCredentialAccessForSubOwner(&context->subject, context->payload, context->payloadSize);
218             break;
219         case OIC_R_ACL_TYPE:
220             //SubOwner can only access the ACL which is registered as the eowner.
221             isValidRequest = IsValidAclAccessForSubOwner(&context->subject, context->payload, context->payloadSize);
222             break;
223         default:
224             //SubOwner has full permission for all resource except the security resource
225             isValidRequest = true;
226             break;
227     }
228
229     if(isValidRequest)
230     {
231         OIC_LOG(INFO, TAG, "PE.IsValidRequestFromSubOwner(): returning true");
232     }
233     else
234     {
235         OIC_LOG(INFO, TAG, "PE.IsValidRequestFromSubOwner(): returning false");
236     }
237
238     return isValidRequest;
239 }
240 #endif //MULTIPLE_OWNER
241
242
243 // TODO - remove these function placeholders as they are implemented
244 // in the resource entity handler code.
245 // Note that because many SVRs do not have a rowner, in those cases we
246 // just return "OC_STACK_ERROR" which results in a "false" return by
247 // IsRequestFromResourceOwner().
248 // As these SVRs are revised to have a rowner, these functions should be
249 // replaced (see pstatresource.c for example of GetPstatRownerId).
250
251 OCStackResult GetCrlRownerId(OicUuid_t *rowner)
252 {
253     OC_UNUSED(rowner);
254     rowner = NULL;
255     return OC_STACK_ERROR;
256 }
257
258 OCStackResult GetSaclRownerId(OicUuid_t *rowner)
259 {
260     OC_UNUSED(rowner);
261     rowner = NULL;
262     return OC_STACK_ERROR;
263 }
264
265 OCStackResult GetSvcRownerId(OicUuid_t *rowner)
266 {
267     OC_UNUSED(rowner);
268     rowner = NULL;
269     return OC_STACK_ERROR;
270 }
271
272 static GetSvrRownerId_t GetSvrRownerId[OIC_SEC_SVR_TYPE_COUNT] = {
273     GetAclRownerId,
274     GetAmaclRownerId,
275     GetCredRownerId,
276     GetCrlRownerId,
277     GetDoxmRownerId,
278     GetDpairingRownerId,
279     GetPconfRownerId,
280     GetPstatRownerId,
281     GetSaclRownerId,
282     GetSvcRownerId
283 };
284
285 /**
286  * Compare the request's subject to resource.ROwner.
287  *
288  * @return true if context->subjectId equals SVR rowner id, else return false
289  */
290 bool IsRequestFromResourceOwner(PEContext_t *context)
291 {
292     bool retVal = false;
293     OicUuid_t resourceOwner;
294
295     if(NULL == context)
296     {
297         return false;
298     }
299
300     if((OIC_R_ACL_TYPE <= context->resourceType) && \
301         (OIC_SEC_SVR_TYPE_COUNT > context->resourceType))
302     {
303         if(OC_STACK_OK == GetSvrRownerId[(int)context->resourceType](&resourceOwner))
304         {
305             retVal = UuidCmp(&context->subject, &resourceOwner);
306         }
307     }
308
309     if(true == retVal)
310     {
311         OIC_LOG(INFO, TAG, "PE.IsRequestFromResourceOwner(): returning true");
312     }
313     else
314     {
315         OIC_LOG(INFO, TAG, "PE.IsRequestFromResourceOwner(): returning false");
316     }
317
318     return retVal;
319 }
320
321 INLINE_API bool IsRequestSubjectEmpty(PEContext_t *context)
322 {
323     OicUuid_t emptySubject = {.id={0}};
324
325     if(NULL == context)
326     {
327         return false;
328     }
329
330     return (memcmp(&context->subject, &emptySubject, sizeof(OicUuid_t)) == 0) ?
331             true : false;
332 }
333
334 /**
335  * Bitwise check to see if 'permission' contains 'request'.
336  *
337  * @param permission is the allowed CRUDN permission.
338  * @param request is the CRUDN permission being requested.
339  *
340  * @return true if 'permission' bits include all 'request' bits.
341  */
342 INLINE_API bool IsPermissionAllowingRequest(const uint16_t permission,
343     const uint16_t request)
344 {
345     if (request == (request & permission))
346     {
347         return true;
348     }
349     else
350     {
351         return false;
352     }
353 }
354
355 /**
356  * Compare the passed subject to the wildcard (aka anonymous) subjectId.
357  *
358  * @return true if 'subject' is the wildcard, false if it is not.
359  */
360 INLINE_API bool IsWildCardSubject(OicUuid_t *subject)
361 {
362     if(NULL == subject)
363     {
364         return false;
365     }
366
367     // Because always comparing to string literal, use strcmp()
368     if(0 == memcmp(subject, &WILDCARD_SUBJECT_ID, sizeof(OicUuid_t)))
369     {
370         return true;
371     }
372     else
373     {
374         return false;
375     }
376 }
377
378 /**
379  * Copy the subject, resource and permission into the context fields.
380  */
381 static void CopyParamsToContext(PEContext_t     *context,
382                                 const OicUuid_t *subjectId,
383                                 const char      *resource,
384                                 const uint16_t  requestedPermission)
385 {
386     size_t length = 0;
387
388     if (NULL == context || NULL == subjectId || NULL == resource)
389     {
390         return;
391     }
392
393     memcpy(&context->subject, subjectId, sizeof(OicUuid_t));
394
395     // Copy the resource string into context.
396     length = sizeof(context->resource) - 1;
397     strncpy(context->resource, resource, length);
398     context->resource[length] = '\0';
399
400
401     // Assign the permission field.
402     context->permission = requestedPermission;
403 }
404
405 /**
406  * Check whether 'resource' is getting accessed within the valid time period.
407  *
408  * @param acl is the ACL to check.
409  *
410  * @return true if access is within valid time period or if the period or recurrence is not present.
411  * false if period and recurrence present and the access is not within valid time period.
412  */
413 static bool IsAccessWithinValidTime(const OicSecAce_t *ace)
414 {
415 #ifndef WITH_ARDUINO //Period & Recurrence not supported on Arduino due
416     //lack of absolute time
417     if (NULL== ace || NULL == ace->validities)
418     {
419         return true;
420     }
421
422     //periods & recurrences rules are paired.
423     if (NULL == ace->validities->recurrences)
424     {
425         return false;
426     }
427
428     OicSecValidity_t* validity =  NULL;
429     LL_FOREACH(ace->validities, validity)
430     {
431         for(size_t i = 0; i < validity->recurrenceLen; i++)
432         {
433             if (IOTVTICAL_VALID_ACCESS ==  IsRequestWithinValidTime(validity->period,
434                 validity->recurrences[i]))
435             {
436                 OIC_LOG(INFO, TAG, "Access request is in allowed time period");
437                 return true;
438             }
439         }
440     }
441     OIC_LOG(ERROR, TAG, "Access request is in invalid time period");
442     return false;
443
444 #else
445     return true;
446 #endif
447 }
448
449 /**
450  * Check whether 'resource' is in the passed ACE.
451  *
452  * @param resource is the resource being searched.
453  * @param ace is the ACE to check.
454  *
455  * @return true if 'resource' found, otherwise false.
456  */
457  static bool IsResourceInAce(const char *resource, const OicSecAce_t *ace)
458 {
459     if (NULL== ace || NULL == resource)
460     {
461         return false;
462     }
463
464     OicSecRsrc_t* rsrc = NULL;
465     LL_FOREACH(ace->resources, rsrc)
466     {
467          if (0 == strcmp(resource, rsrc->href) || // TODO null terms?
468              0 == strcmp(WILDCARD_RESOURCE_URI, rsrc->href))
469          {
470              return true;
471          }
472     }
473     return false;
474 }
475
476
477 /**
478  * Find ACLs containing context->subject.
479  * Search each ACL for requested resource.
480  * If resource found, check for context->permission and period validity.
481  * If the ACL is not found locally and AMACL for the resource is found
482  * then sends the request to AMS service for the ACL.
483  * Set context->retVal to result from first ACL found which contains
484  * correct subject AND resource.
485  */
486 static void ProcessAccessRequest(PEContext_t *context)
487 {
488     if (NULL != context)
489     {
490         const OicSecAce_t *currentAce = NULL;
491         OicSecAce_t *savePtr = NULL;
492
493         OIC_LOG_V(DEBUG, TAG, "Entering ProcessAccessRequest(%s)", context->resource);
494
495         // Start out assuming subject not found.
496         context->retVal = ACCESS_DENIED_SUBJECT_NOT_FOUND;
497
498         // Loop through all ACLs with a matching Subject searching for the right
499         // ACL for this request.
500         do
501         {
502             OIC_LOG_V(DEBUG, TAG, "%s: getting ACE..." ,__func__);
503             currentAce = GetACLResourceData(&context->subject, &savePtr);
504
505             if (NULL != currentAce)
506             {
507                 // Found the subject, so how about resource?
508                 OIC_LOG_V(DEBUG, TAG, "%s:found ACE matching subject" ,__func__);
509
510                 // Subject was found, so err changes to Rsrc not found for now.
511                 context->retVal = ACCESS_DENIED_RESOURCE_NOT_FOUND;
512                 OIC_LOG_V(DEBUG, TAG, "%s:Searching for resource..." ,__func__);
513                 if (IsResourceInAce(context->resource, currentAce))
514                 {
515                     OIC_LOG_V(INFO, TAG, "%s:found matching resource in ACE" ,__func__);
516
517                     // Found the resource, so it's down to valid period & permission.
518                     context->retVal = ACCESS_DENIED_INVALID_PERIOD;
519                     if (IsAccessWithinValidTime(currentAce))
520                     {
521                         context->retVal = ACCESS_DENIED_INSUFFICIENT_PERMISSION;
522                         if (IsPermissionAllowingRequest(currentAce->permission, context->permission))
523                         {
524                             context->retVal = ACCESS_GRANTED;
525                         }
526                     }
527                 }
528             }
529             else
530             {
531                 OIC_LOG_V(INFO, TAG, "%s:no ACL found matching subject for resource %s",__func__, context->resource);
532             }
533         } while ((NULL != currentAce) && (ACCESS_GRANTED != context->retVal));
534
535         if (IsAccessGranted(context->retVal))
536         {
537             OIC_LOG_V(INFO, TAG, "%s:Leaving ProcessAccessRequest(ACCESS_GRANTED)", __func__);
538         }
539         else
540         {
541             OIC_LOG_V(INFO, TAG, "%s:Leaving ProcessAccessRequest(ACCESS_DENIED)", __func__);
542         }
543     }
544     else
545     {
546         OIC_LOG_V(ERROR, TAG, "%s:Leaving ProcessAccessRequest(context is NULL)", __func__);
547     }
548 }
549
550 SRMAccessResponse_t CheckPermission(PEContext_t     *context,
551                                     const OicUuid_t *subjectId,
552                                     const char      *resource,
553                                     const uint16_t  requestedPermission)
554 {
555     SRMAccessResponse_t retVal = ACCESS_DENIED_POLICY_ENGINE_ERROR;
556
557     VERIFY_NON_NULL(TAG, context, ERROR);
558     VERIFY_NON_NULL(TAG, subjectId, ERROR);
559     VERIFY_NON_NULL(TAG, resource, ERROR);
560
561     // Each state machine context can only be processing one request at a time.
562     // Therefore if the context is not in AWAITING_REQUEST or AWAITING_AMS_RESPONSE
563     // state, return error. Otherwise, change to BUSY state and begin processing request.
564     if (AWAITING_REQUEST == context->state || AWAITING_AMS_RESPONSE == context->state)
565     {
566         if (AWAITING_REQUEST == context->state)
567         {
568             SetPolicyEngineState(context, BUSY);
569             CopyParamsToContext(context, subjectId, resource, requestedPermission);
570         }
571
572         // Before doing any ACL processing, check if request a) coming
573         // from DevOwner AND b) the device is in Ready for OTM or Reset state
574         // (which in IoTivity is equivalent to isOp == false && owned == false)
575         // AND c) the request is for a SVR resource.
576         // If all 3 conditions are met, grant request.
577         bool isDeviceOwned = true; // default to value that will not grant access
578         if (OC_STACK_OK != GetDoxmIsOwned(&isDeviceOwned)) // if runtime error, don't grant
579         {
580             context->retVal = ACCESS_DENIED_POLICY_ENGINE_ERROR;
581         }
582         // If we were able to get the value of doxm->isOwned, proceed with
583         // test for implicit access...
584         else if (IsRequestFromDevOwner(context) // if from DevOwner
585         && (GetPstatIsop() == false) // AND if pstat->isOp == false
586         && (isDeviceOwned == false) // AND if doxm->isOwned == false
587         && (context->resourceType != NOT_A_SVR_RESOURCE)) // AND if SVR type
588         {
589             context->retVal = ACCESS_GRANTED;
590         }
591         // If not granted via DevOwner status and not a subowner,
592         // then check if request is for a SVR and coming from rowner
593         else if (IsRequestFromResourceOwner(context))
594         {
595             context->retVal = ACCESS_GRANTED;
596         }
597 #ifdef MULTIPLE_OWNER
598         //Then check if request from SubOwner
599         else if(IsRequestFromSubOwner(context))
600         {
601             if(IsValidRequestFromSubOwner(context))
602             {
603                 context->retVal = ACCESS_GRANTED;
604             }
605         }
606 #endif //MULTIPLE_OWNER
607         // Else request is a "normal" request that must be tested against ACL
608         else
609         {
610             OicUuid_t saveSubject = {.id={0}};
611             bool isSubEmpty = IsRequestSubjectEmpty(context);
612
613             ProcessAccessRequest(context);
614
615             // If access not already granted, and requested subject != wildcard,
616             // try looking for a wildcard ACE that grants access.
617             if ((ACCESS_GRANTED != context->retVal) && \
618               (false == IsWildCardSubject(&context->subject)))
619             {
620                 //Saving subject for Amacl check
621                 memcpy(&saveSubject, &context->subject,sizeof(OicUuid_t));
622
623                 //Setting context subject to WILDCARD_SUBJECT_ID
624                 //TODO: change ProcessAccessRequest method signature to
625                 //ProcessAccessRequest(context, subject) so that context
626                 //subject is not tempered.
627                 memset(&context->subject, 0, sizeof(context->subject));
628                 memcpy(&context->subject, &WILDCARD_SUBJECT_ID,sizeof(OicUuid_t));
629                 ProcessAccessRequest(context); // TODO anonymous subj can result
630                                                // in confusing err code return.
631             }
632
633             //No local ACE found for the request so checking Amacl resource
634             if (ACCESS_GRANTED != context->retVal)
635             {
636                 //If subject is not empty then restore the original subject
637                 //else keep the subject to WILDCARD_SUBJECT_ID
638                 if(!isSubEmpty)
639                 {
640                     memcpy(&context->subject, &saveSubject, sizeof(OicUuid_t));
641                 }
642
643                 //FoundAmaclForRequest method checks for Amacl and fills up
644                 //context->amsMgrContext->amsDeviceId with the AMS deviceId
645                 //if Amacl was found for the requested resource.
646                 if(FoundAmaclForRequest(context))
647                 {
648                     ProcessAMSRequest(context);
649                 }
650             }
651         }
652     }
653     else
654     {
655         context->retVal = ACCESS_DENIED_POLICY_ENGINE_ERROR;
656     }
657
658     // Capture retVal before resetting state for next request.
659     retVal = context->retVal;
660
661    if (!context->amsProcessing)
662     {
663         OIC_LOG(INFO, TAG, "Resetting PE context and PE State to AWAITING_REQUEST");
664         SetPolicyEngineState(context, AWAITING_REQUEST);
665     }
666
667 exit:
668     return retVal;
669 }
670
671 OCStackResult InitPolicyEngine(PEContext_t *context)
672 {
673     if(NULL == context)
674     {
675         return OC_STACK_ERROR;
676     }
677
678     context->amsMgrContext = (AmsMgrContext_t *)OICCalloc(1, sizeof(AmsMgrContext_t));
679     if(NULL == context->amsMgrContext)
680     {
681         return OC_STACK_ERROR;
682     }
683
684     SetPolicyEngineState(context, AWAITING_REQUEST);
685     return OC_STACK_OK;
686 }
687
688 void DeInitPolicyEngine(PEContext_t *context)
689 {
690     if(NULL != context)
691     {
692         SetPolicyEngineState(context, STOPPED);
693         OICFree(context->amsMgrContext);
694     }
695     return;
696 }