Added "GetSvrTypeFromUri()" and supporting code.
[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 "amsmgr.h"
30 #include "oic_string.h"
31 #include "oic_malloc.h"
32 #include "securevirtualresourcetypes.h"
33 #include "secureresourcemanager.h"
34 #include "srmresourcestrings.h"
35
36 #define TAG  "SRM"
37
38 #ifdef __WITH_X509__
39 #include "crlresource.h"
40 #endif // __WITH_X509__
41
42 //Request Callback handler
43 static CARequestCallback gRequestHandler = NULL;
44 //Response Callback handler
45 static CAResponseCallback gResponseHandler = NULL;
46 //Error Callback handler
47 static CAErrorCallback gErrorHandler = NULL;
48 //Persistent Storage callback handler for open/read/write/close/unlink
49 static OCPersistentStorage *gPersistentStorageHandler =  NULL;
50 //Provisioning response callback
51 static SPResponseCallback gSPResponseHandler = NULL;
52
53 /**
54  * A single global Policy Engine context will suffice as long
55  * as SRM is single-threaded.
56  */
57 PEContext_t g_policyEngineContext;
58
59 /**
60  * Function to register provisoning API's response callback.
61  * @param respHandler response handler callback.
62  */
63 void SRMRegisterProvisioningResponseHandler(SPResponseCallback respHandler)
64 {
65     gSPResponseHandler = respHandler;
66 }
67
68 void SetResourceRequestType(PEContext_t *context, const char *resourceUri)
69 {
70     context->resourceType = GetSvrTypeFromUri(resourceUri);
71 }
72
73 static void SRMSendUnAuthorizedAccessresponse(PEContext_t *context)
74 {
75     CAResponseInfo_t responseInfo = {.result = CA_EMPTY};
76
77     if (NULL == context ||
78        NULL == context->amsMgrContext->requestInfo)
79     {
80         OIC_LOG_V(ERROR, TAG, "%s : NULL Parameter(s)",__func__);
81         return;
82     }
83
84     memcpy(&responseInfo.info, &(context->amsMgrContext->requestInfo->info),
85             sizeof(responseInfo.info));
86     responseInfo.info.payload = NULL;
87     responseInfo.result = CA_UNAUTHORIZED_REQ;
88
89     if (CA_STATUS_OK == CASendResponse(context->amsMgrContext->endpoint, &responseInfo))
90     {
91         OIC_LOG(DEBUG, TAG, "Succeed in sending response to a unauthorized request!");
92     }
93     else
94     {
95         OIC_LOG(ERROR, TAG, "Failed in sending response to a unauthorized request!");
96     }
97 }
98
99 void SRMSendResponse(SRMAccessResponse_t responseVal)
100 {
101     OIC_LOG(DEBUG, TAG, "Sending response to remote device");
102
103     if (IsAccessGranted(responseVal) && gRequestHandler)
104     {
105         OIC_LOG_V(INFO, TAG, "%s : Access granted. Passing Request to RI layer", __func__);
106         if (!g_policyEngineContext.amsMgrContext->endpoint ||
107             !g_policyEngineContext.amsMgrContext->requestInfo)
108         {
109             OIC_LOG_V(ERROR, TAG, "%s : Invalid arguments", __func__);
110             SRMSendUnAuthorizedAccessresponse(&g_policyEngineContext);
111             goto exit;
112         }
113         gRequestHandler(g_policyEngineContext.amsMgrContext->endpoint,
114                 g_policyEngineContext.amsMgrContext->requestInfo);
115     }
116     else
117     {
118         OIC_LOG_V(INFO, TAG, "%s : ACCESS_DENIED.", __func__);
119         SRMSendUnAuthorizedAccessresponse(&g_policyEngineContext);
120     }
121
122 exit:
123     //Resetting PE state to AWAITING_REQUEST
124     SetPolicyEngineState(&g_policyEngineContext, AWAITING_REQUEST);
125 }
126
127 /**
128  * Handle the request from the SRM.
129  *
130  * @param endPoint object from which the response is received.
131  * @param requestInfo contains information for the request.
132  */
133 void SRMRequestHandler(const CAEndpoint_t *endPoint, const CARequestInfo_t *requestInfo)
134 {
135     OIC_LOG(DEBUG, TAG, "Received request from remote device");
136
137     if (!endPoint || !requestInfo)
138     {
139         OIC_LOG(ERROR, TAG, "Invalid arguments");
140         return;
141     }
142
143     // Copy the subjectID
144     OicUuid_t subjectId = {.id = {0}};
145     memcpy(subjectId.id, requestInfo->info.identity.id, sizeof(subjectId.id));
146
147     //Check the URI has the query and skip it before checking the permission
148     char *uri = strstr(requestInfo->info.resourceUri, "?");
149     int position = 0;
150     if (uri)
151     {
152         //Skip query and pass the resource uri
153         position = uri - requestInfo->info.resourceUri;
154     }
155     else
156     {
157         position = strlen(requestInfo->info.resourceUri);
158     }
159     if (MAX_URI_LENGTH < position  || 0 > position)
160     {
161         OIC_LOG(ERROR, TAG, "Incorrect URI length");
162         return;
163     }
164     SRMAccessResponse_t response = ACCESS_DENIED;
165     char newUri[MAX_URI_LENGTH + 1];
166     OICStrcpyPartial(newUri, MAX_URI_LENGTH + 1, requestInfo->info.resourceUri, position);
167
168     SetResourceRequestType(&g_policyEngineContext, newUri);
169
170     //New request are only processed if the policy engine state is AWAITING_REQUEST.
171     if (AWAITING_REQUEST == g_policyEngineContext.state)
172     {
173         OIC_LOG_V(DEBUG, TAG, "Processing request with uri, %s for method, %d",
174                 requestInfo->info.resourceUri, requestInfo->method);
175         response = CheckPermission(&g_policyEngineContext, &subjectId, newUri,
176                 GetPermissionFromCAMethod_t(requestInfo->method));
177     }
178     else
179     {
180         OIC_LOG_V(INFO, TAG, "PE state %d. Ignoring request with uri, %s for method, %d",
181                 g_policyEngineContext.state, requestInfo->info.resourceUri, requestInfo->method);
182     }
183
184     if (IsAccessGranted(response) && gRequestHandler)
185     {
186         return (gRequestHandler(endPoint, requestInfo));
187     }
188
189     // Form a 'Error', 'slow response' or 'access deny' response and send to peer
190     CAResponseInfo_t responseInfo = {.result = CA_EMPTY};
191     memcpy(&responseInfo.info, &(requestInfo->info), sizeof(responseInfo.info));
192     responseInfo.info.payload = NULL;
193
194     VERIFY_NON_NULL(TAG, gRequestHandler, ERROR);
195
196     if (ACCESS_WAITING_FOR_AMS == response)
197     {
198         OIC_LOG(INFO, TAG, "Sending slow response");
199
200         UpdateAmsMgrContext(&g_policyEngineContext, endPoint, requestInfo);
201         responseInfo.result = CA_EMPTY;
202         responseInfo.info.type = CA_MSG_ACKNOWLEDGE;
203     }
204     else
205     {
206         /*
207          * TODO Enhance this logic more to decide between
208          * CA_UNAUTHORIZED_REQ or CA_FORBIDDEN_REQ depending
209          * upon SRMAccessResponseReasonCode_t
210          */
211         OIC_LOG(INFO, TAG, "Sending for regular response");
212         responseInfo.result = CA_UNAUTHORIZED_REQ;
213     }
214
215     if (CA_STATUS_OK != CASendResponse(endPoint, &responseInfo))
216     {
217         OIC_LOG(ERROR, TAG, "Failed in sending response to a unauthorized request!");
218     }
219     return;
220 exit:
221     responseInfo.result = CA_INTERNAL_SERVER_ERROR;
222     if (CA_STATUS_OK != CASendResponse(endPoint, &responseInfo))
223     {
224         OIC_LOG(ERROR, TAG, "Failed in sending response to a unauthorized request!");
225     }
226 }
227
228 /**
229  * Handle the response from the SRM.
230  *
231  * @param endPoint points to the remote endpoint.
232  * @param responseInfo contains response information from the endpoint.
233  */
234 void SRMResponseHandler(const CAEndpoint_t *endPoint, const CAResponseInfo_t *responseInfo)
235 {
236     OIC_LOG(DEBUG, TAG, "Received response from remote device");
237
238     // isProvResponse flag is to check whether response is catered by provisioning APIs or not.
239     // When token sent by CA response matches with token generated by provisioning request,
240     // gSPResponseHandler returns true and response is not sent to RI layer. In case
241     // gSPResponseHandler is null and isProvResponse is false response then the response is for
242     // RI layer.
243     bool isProvResponse = false;
244
245     if (gSPResponseHandler)
246     {
247         isProvResponse = gSPResponseHandler(endPoint, responseInfo);
248     }
249     if (!isProvResponse && gResponseHandler)
250     {
251         gResponseHandler(endPoint, responseInfo);
252     }
253 }
254
255 /**
256  * Handle the error from the SRM.
257  *
258  * @param endPoint is the remote endpoint.
259  * @param errorInfo contains error information from the endpoint.
260  */
261 void SRMErrorHandler(const CAEndpoint_t *endPoint, const CAErrorInfo_t *errorInfo)
262 {
263     OIC_LOG_V(INFO, TAG, "Received error from remote device with result, %d for request uri, %s",
264             errorInfo->result, errorInfo->info.resourceUri);
265     if (gErrorHandler)
266     {
267         gErrorHandler(endPoint, errorInfo);
268     }
269 }
270
271 OCStackResult SRMRegisterHandler(CARequestCallback reqHandler,
272                                  CAResponseCallback respHandler,
273                                  CAErrorCallback errHandler)
274 {
275     OIC_LOG(DEBUG, TAG, "SRMRegisterHandler !!");
276     if( !reqHandler || !respHandler || !errHandler)
277     {
278         OIC_LOG(ERROR, TAG, "Callback handlers are invalid");
279         return OC_STACK_INVALID_PARAM;
280     }
281     gRequestHandler = reqHandler;
282     gResponseHandler = respHandler;
283     gErrorHandler = errHandler;
284
285
286 #if defined(__WITH_DTLS__)
287     CARegisterHandler(SRMRequestHandler, SRMResponseHandler, SRMErrorHandler);
288 #else
289     CARegisterHandler(reqHandler, respHandler, errHandler);
290 #endif /* __WITH_DTLS__ */
291     return OC_STACK_OK;
292 }
293
294 OCStackResult SRMRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
295 {
296     OIC_LOG(DEBUG, TAG, "SRMRegisterPersistentStorageHandler !!");
297     if(!persistentStorageHandler)
298     {
299         OIC_LOG(ERROR, TAG, "The persistent storage handler is invalid");
300         return OC_STACK_INVALID_PARAM;
301     }
302     gPersistentStorageHandler = persistentStorageHandler;
303     return OC_STACK_OK;
304 }
305
306 OCPersistentStorage* SRMGetPersistentStorageHandler()
307 {
308     return gPersistentStorageHandler;
309 }
310
311 OCStackResult SRMInitSecureResources()
312 {
313     // TODO: temporarily returning OC_STACK_OK every time until default
314     // behavior (for when SVR DB is missing) is settled.
315     InitSecureResources();
316     OCStackResult ret = OC_STACK_OK;
317 #if defined(__WITH_DTLS__)
318     if(CA_STATUS_OK != CARegisterDTLSCredentialsHandler(GetDtlsPskCredentials))
319     {
320         OIC_LOG(ERROR, TAG, "Failed to revert DTLS credential handler.");
321         ret = OC_STACK_ERROR;
322     }
323
324 #endif // (__WITH_DTLS__)
325 #if defined(__WITH_X509__)
326     CARegisterDTLSX509CredentialsHandler(GetDtlsX509Credentials);
327     CARegisterDTLSCrlHandler(GetDerCrl);
328 #endif // (__WITH_X509__)
329
330     return ret;
331 }
332
333 void SRMDeInitSecureResources()
334 {
335     DestroySecureResources();
336 }
337
338 OCStackResult SRMInitPolicyEngine()
339 {
340     return InitPolicyEngine(&g_policyEngineContext);
341 }
342
343 void SRMDeInitPolicyEngine()
344 {
345     return DeInitPolicyEngine(&g_policyEngineContext);
346 }
347
348 bool SRMIsSecurityResourceURI(const char* uri)
349 {
350     if (!uri)
351     {
352         return false;
353     }
354
355     const char *rsrcs[] = {
356         OIC_RSRC_SVC_URI,
357         OIC_RSRC_AMACL_URI,
358         OIC_RSRC_CRL_URI,
359         OIC_RSRC_CRED_URI,
360         OIC_RSRC_ACL_URI,
361         OIC_RSRC_DOXM_URI,
362         OIC_RSRC_PSTAT_URI,
363         OIC_RSRC_PCONF_URI,
364         OIC_RSRC_DPAIRING_URI,
365     };
366
367     // Remove query from Uri for resource string comparison
368     size_t uriLen = strlen(uri);
369     char *query = strchr (uri, '?');
370     if (query)
371     {
372         uriLen = query - uri;
373     }
374
375     for (size_t i = 0; i < sizeof(rsrcs)/sizeof(rsrcs[0]); i++)
376     {
377         size_t svrLen = strlen(rsrcs[i]);
378
379         if ((uriLen == svrLen) &&
380             (strncmp(uri, rsrcs[i], svrLen) == 0))
381         {
382             return true;
383         }
384     }
385
386     return false;
387 }
388
389 /**
390  * Get the Secure Virtual Resource (SVR) type from the URI.
391  * @param   uri [IN] Pointer to URI in question.
392  * @return  The OicSecSvrType_t of the URI passed (note: if not a Secure Virtual
393             Resource, e.g. /a/light, will return "NOT_A_SVR_TYPE" enum value)
394  */
395 static const char URI_QUERY_CHAR = '?';
396 OicSecSvrType_t GetSvrTypeFromUri(const char* uri)
397 {
398     if (!uri)
399     {
400         return NOT_A_SVR_RESOURCE;
401     }
402
403     // Remove query from Uri for resource string comparison
404     size_t uriLen = strlen(uri);
405     char *query = strchr (uri, URI_QUERY_CHAR);
406     if (query)
407     {
408         uriLen = query - uri;
409     }
410
411     size_t svrLen = 0;
412
413     svrLen = strlen(OIC_RSRC_ACL_URI);
414     if(uriLen == svrLen)
415     {
416         if(0 == strncmp(uri, OIC_RSRC_ACL_URI, svrLen))
417         {
418             return OIC_R_ACL_TYPE;
419         }
420     }
421
422     svrLen = strlen(OIC_RSRC_AMACL_URI);
423     if(uriLen == svrLen)
424     {
425         if(0 == strncmp(uri, OIC_RSRC_AMACL_URI, svrLen))
426         {
427             return OIC_R_AMACL_TYPE;
428         }
429     }
430
431     svrLen = strlen(OIC_RSRC_CRED_URI);
432     if(uriLen == svrLen)
433     {
434         if(0 == strncmp(uri, OIC_RSRC_CRED_URI, svrLen))
435         {
436             return OIC_R_CRED_TYPE;
437         }
438     }
439
440     svrLen = strlen(OIC_RSRC_CRL_URI);
441     if(uriLen == svrLen)
442     {
443         if(0 == strncmp(uri, OIC_RSRC_CRL_URI, svrLen))
444         {
445             return OIC_R_CRL_TYPE;
446         }
447     }
448
449     svrLen = strlen(OIC_RSRC_DOXM_URI);
450     if(uriLen == svrLen)
451     {
452         if(0 == strncmp(uri, OIC_RSRC_DOXM_URI, svrLen))
453         {
454             return OIC_R_DOXM_TYPE;
455         }
456     }
457
458     svrLen = strlen(OIC_RSRC_DPAIRING_URI);
459     if(uriLen == svrLen)
460     {
461         if(0 == strncmp(uri, OIC_RSRC_DPAIRING_URI, svrLen))
462         {
463             return OIC_R_DPAIRING_TYPE;
464         }
465     }
466
467     svrLen = strlen(OIC_RSRC_PCONF_URI);
468     if(uriLen == svrLen)
469     {
470         if(0 == strncmp(uri, OIC_RSRC_PCONF_URI, svrLen))
471         {
472             return OIC_R_PCONF_TYPE;
473         }
474     }
475
476     svrLen = strlen(OIC_RSRC_PSTAT_URI);
477     if(uriLen == svrLen)
478     {
479         if(0 == strncmp(uri, OIC_RSRC_PSTAT_URI, svrLen))
480         {
481             return OIC_R_PSTAT_TYPE;
482         }
483     }
484
485     svrLen = strlen(OIC_RSRC_SVC_URI);
486     if(uriLen == svrLen)
487     {
488         if(0 == strncmp(uri, OIC_RSRC_SVC_URI, svrLen))
489         {
490             return OIC_R_SVC_TYPE;
491         }
492     }
493
494     svrLen = strlen(OIC_RSRC_SACL_URI);
495     if(uriLen == svrLen)
496     {
497         if(0 == strncmp(uri, OIC_RSRC_SACL_URI, svrLen))
498         {
499             return OIC_R_SACL_TYPE;
500         }
501     }
502
503     return NOT_A_SVR_RESOURCE;
504 }