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         OIC_RSRC_VER_URI,
 366     };
 367
 368     // Remove query from Uri for resource string comparison
 369     size_t uriLen = strlen(uri);
 370     char *query = strchr (uri, '?');
 371     if (query)
 372     {
 373         uriLen = query - uri;
 374     }
 375
 376     for (size_t i = 0; i < sizeof(rsrcs)/sizeof(rsrcs[0]); i++)
 377     {
 378         size_t svrLen = strlen(rsrcs[i]);
 379
 380         if ((uriLen == svrLen) &&
 381             (strncmp(uri, rsrcs[i], svrLen) == 0))
 382         {
 383             return true;
 384         }
 385     }
 386
 387     return false;
 388 }
 389
 390 /**
 391  * Get the Secure Virtual Resource (SVR) type from the URI.
 392  * @param   uri [IN] Pointer to URI in question.
 393  * @return  The OicSecSvrType_t of the URI passed (note: if not a Secure Virtual
 394             Resource, e.g. /a/light, will return "NOT_A_SVR_TYPE" enum value)
 395  */
 396 static const char URI_QUERY_CHAR = '?';
 397 OicSecSvrType_t GetSvrTypeFromUri(const char* uri)
 398 {
 399     if (!uri)
 400     {
 401         return NOT_A_SVR_RESOURCE;
 402     }
 403
 404     // Remove query from Uri for resource string comparison
 405     size_t uriLen = strlen(uri);
 406     char *query = strchr (uri, URI_QUERY_CHAR);
 407     if (query)
 408     {
 409         uriLen = query - uri;
 410     }
 411
 412     size_t svrLen = 0;
 413
 414     svrLen = strlen(OIC_RSRC_ACL_URI);
 415     if(uriLen == svrLen)
 416     {
 417         if(0 == strncmp(uri, OIC_RSRC_ACL_URI, svrLen))
 418         {
 419             return OIC_R_ACL_TYPE;
 420         }
 421     }
 422
 423     svrLen = strlen(OIC_RSRC_AMACL_URI);
 424     if(uriLen == svrLen)
 425     {
 426         if(0 == strncmp(uri, OIC_RSRC_AMACL_URI, svrLen))
 427         {
 428             return OIC_R_AMACL_TYPE;
 429         }
 430     }
 431
 432     svrLen = strlen(OIC_RSRC_CRED_URI);
 433     if(uriLen == svrLen)
 434     {
 435         if(0 == strncmp(uri, OIC_RSRC_CRED_URI, svrLen))
 436         {
 437             return OIC_R_CRED_TYPE;
 438         }
 439     }
 440
 441     svrLen = strlen(OIC_RSRC_CRL_URI);
 442     if(uriLen == svrLen)
 443     {
 444         if(0 == strncmp(uri, OIC_RSRC_CRL_URI, svrLen))
 445         {
 446             return OIC_R_CRL_TYPE;
 447         }
 448     }
 449
 450     svrLen = strlen(OIC_RSRC_DOXM_URI);
 451     if(uriLen == svrLen)
 452     {
 453         if(0 == strncmp(uri, OIC_RSRC_DOXM_URI, svrLen))
 454         {
 455             return OIC_R_DOXM_TYPE;
 456         }
 457     }
 458
 459     svrLen = strlen(OIC_RSRC_DPAIRING_URI);
 460     if(uriLen == svrLen)
 461     {
 462         if(0 == strncmp(uri, OIC_RSRC_DPAIRING_URI, svrLen))
 463         {
 464             return OIC_R_DPAIRING_TYPE;
 465         }
 466     }
 467
 468     svrLen = strlen(OIC_RSRC_PCONF_URI);
 469     if(uriLen == svrLen)
 470     {
 471         if(0 == strncmp(uri, OIC_RSRC_PCONF_URI, svrLen))
 472         {
 473             return OIC_R_PCONF_TYPE;
 474         }
 475     }
 476
 477     svrLen = strlen(OIC_RSRC_PSTAT_URI);
 478     if(uriLen == svrLen)
 479     {
 480         if(0 == strncmp(uri, OIC_RSRC_PSTAT_URI, svrLen))
 481         {
 482             return OIC_R_PSTAT_TYPE;
 483         }
 484     }
 485
 486     svrLen = strlen(OIC_RSRC_SVC_URI);
 487     if(uriLen == svrLen)
 488     {
 489         if(0 == strncmp(uri, OIC_RSRC_SVC_URI, svrLen))
 490         {
 491             return OIC_R_SVC_TYPE;
 492         }
 493     }
 494
 495     svrLen = strlen(OIC_RSRC_SACL_URI);
 496     if(uriLen == svrLen)
 497     {
 498         if(0 == strncmp(uri, OIC_RSRC_SACL_URI, svrLen))
 499         {
 500             return OIC_R_SACL_TYPE;
 501         }
 502     }
 503
 504     return NOT_A_SVR_RESOURCE;
 505 }