resource/csdk/security/src/amsmgr.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 "oic_malloc.h"
  22 #include "amsmgr.h"
  23 #include "resourcemanager.h"
  24 #include "securevirtualresourcetypes.h"
  25 #include "srmresourcestrings.h"
  26 #include "logger.h"
  27 #include "ocrandom.h"
  28 #include "aclresource.h"
  29 #include "amaclresource.h"
  30 #include "srmutility.h"
  31 #include "base64.h"
  32 #include "secureresourcemanager.h"
  33 #include "doxmresource.h"
  34 #include "policyengine.h"
  35 #include "oic_string.h"
  36 #include "caremotehandler.h"
  37 #include <string.h>
  38
  39 #define TAG "SRM-AMSMGR"
  40
  41
  42  //Callback for AMS service multicast discovery request.
  43 static OCStackApplicationResult AmsMgrDiscoveryCallback(void *ctx, OCDoHandle handle,
  44                          OCClientResponse * clientResponse);
  45
  46 //Callback for unicast secured port discovery request.
  47 static OCStackApplicationResult SecurePortDiscoveryCallback(void *ctx, OCDoHandle handle,
  48                          OCClientResponse * clientResponse);
  49
  50 //Callback for unicast ACL request
  51 static OCStackApplicationResult AmsMgrAclReqCallback(void *ctx, OCDoHandle handle,
  52     OCClientResponse * clientResponse);
  53
  54
  55 OCStackResult DiscoverAmsService(PEContext_t *context)
  56 {
  57     OIC_LOG(INFO, TAG, "IN DiscoverAmsService");
  58
  59     OCStackResult ret = OC_STACK_ERROR;
  60     const char DOXM_DEVICEID_QUERY_FMT[] = "%s?%s=%s";
  61     char uri[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {};
  62     OCCallbackData cbData = {.context=NULL};
  63     char base64Buff[B64ENCODE_OUT_SAFESIZE(sizeof(((OicUuid_t*)0)->id)) + 1] = {};
  64     uint32_t outLen = 0;
  65     B64Result b64Ret;
  66
  67     VERIFY_NON_NULL(TAG, context, ERROR);
  68     b64Ret = b64Encode(context->amsMgrContext->amsDeviceId.id,
  69           sizeof(context->amsMgrContext->amsDeviceId.id), base64Buff, sizeof(base64Buff), &outLen);
  70     VERIFY_SUCCESS(TAG, B64_OK == b64Ret, ERROR);
  71     snprintf(uri, sizeof(uri), DOXM_DEVICEID_QUERY_FMT, OIC_RSRC_DOXM_URI,
  72                                        OIC_JSON_DEVICE_ID_NAME, base64Buff);
  73
  74     cbData.cb = &AmsMgrDiscoveryCallback;
  75     cbData.context = (void*)context;
  76
  77     /* TODO
  78      * If no good response was received for this discovery request,
  79      * PE would be blocked forever waiting for AMS service to respond with the ACE.
  80      * Need logic to reset the PE state and send ACCESS_DENIED response,
  81      * when discovery response from AMS service is not received within certain time.
  82      */
  83     OIC_LOG_V(INFO, TAG,"AMS Manager Sending Multicast Discovery with URI = %s", uri);
  84     ret = OCDoResource(NULL, OC_REST_DISCOVER, uri, NULL, NULL,
  85                        CT_DEFAULT, OC_LOW_QOS, &cbData, NULL, 0);
  86
  87 exit:
  88     OIC_LOG(INFO, TAG, "Leaving DiscoverAmsService");
  89     return ret;
  90 }
  91
  92
  93 static OCStackApplicationResult AmsMgrDiscoveryCallback(void *ctx, OCDoHandle handle,
  94                          OCClientResponse * clientResponse)
  95 {
  96     OIC_LOG_V(INFO, TAG, "%s Begin", __func__ );
  97
  98     if (!ctx ||
  99         !clientResponse ||
 100         !clientResponse->payload||
 101         (PAYLOAD_TYPE_SECURITY != clientResponse->payload->type)||
 102         (OC_STACK_OK != clientResponse->result))
 103     {
 104         OIC_LOG_V(ERROR, TAG, "%s Invalid Response ", __func__);
 105         return OC_STACK_KEEP_TRANSACTION;
 106     }
 107
 108     (void)handle;
 109     PEContext_t *context = (PEContext_t *) ctx;
 110     if (context->state != AWAITING_AMS_RESPONSE)
 111     {
 112         OIC_LOG_V(ERROR, TAG, "%s Invalid PE State ", __func__);
 113         return OC_STACK_DELETE_TRANSACTION;
 114     }
 115
 116     OicSecDoxm_t *doxm = NULL;
 117     OIC_LOG_V(INFO, TAG, "Doxm DeviceId Discovery response = %s\n",
 118           ((OCSecurityPayload*)clientResponse->payload)->securityData);
 119     doxm = JSONToDoxmBin(((OCSecurityPayload*)clientResponse->payload)->securityData);
 120
 121     //As doxm is NULL amsmgr can't test if response from trusted AMS service
 122     //so keep the transaction.
 123     if(NULL == doxm)
 124     {
 125         OIC_LOG_V(ERROR, TAG, "%s : Unable to convert JSON to Binary",__func__);
 126         return OC_STACK_KEEP_TRANSACTION;
 127     }
 128
 129     OicUuid_t deviceId = {.id={}};
 130     memcpy(&deviceId, &doxm->deviceID, sizeof(deviceId));
 131     OICFree(doxm);
 132
 133     /* TODO : By assuming that the first response received is the actual
 134      * AMS service, a 'bad device' can cause DoS attack.
 135      */
 136     if (memcmp(&context->amsMgrContext->amsDeviceId, &deviceId,
 137             sizeof(context->amsMgrContext->amsDeviceId)) == 0)
 138     {
 139         OIC_LOG(INFO, TAG, "AMS Manager Sending unicast discovery to get secured port info");
 140         //Sending Unicast discovery to get secure port information
 141         if(OC_STACK_OK == SendUnicastSecurePortDiscovery(context, &clientResponse->devAddr,
 142                 clientResponse->connType))
 143         {
 144             context->retVal = ACCESS_WAITING_FOR_AMS;
 145             return OC_STACK_DELETE_TRANSACTION;
 146         }
 147     }
 148     context->retVal = ACCESS_DENIED_AMS_SERVICE_ERROR;
 149     SRMSendResponse(context->retVal);
 150     return OC_STACK_DELETE_TRANSACTION;
 151 }
 152
 153
 154 OCStackResult SendUnicastSecurePortDiscovery(PEContext_t *context,OCDevAddr *devAddr,
 155                                       OCConnectivityType connType)
 156 {
 157     OIC_LOG(INFO, TAG, "IN SendUnicastSecurePortDiscovery");
 158
 159     const char RES_DOXM_QUERY_FMT[] = "%s?%s=%s";
 160     OCCallbackData cbData = {.context=NULL};
 161     char uri[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {};
 162     snprintf(uri, sizeof(uri), RES_DOXM_QUERY_FMT, OC_RSRVD_WELL_KNOWN_URI,
 163             OC_RSRVD_RESOURCE_TYPE, OIC_RSRC_TYPE_SEC_DOXM);
 164
 165     cbData.cb = &SecurePortDiscoveryCallback;
 166     cbData.context = context;
 167
 168     OIC_LOG_V(INFO, TAG, "AMS Manager Sending Unicast Discovery with URI = %s", uri);
 169
 170     return  OCDoResource(NULL, OC_REST_DISCOVER, uri, devAddr, NULL,
 171                          connType, OC_LOW_QOS, &cbData, NULL, 0);
 172 }
 173
 174 static OCStackApplicationResult SecurePortDiscoveryCallback(void *ctx, OCDoHandle handle,
 175                          OCClientResponse * clientResponse)
 176 {
 177     OIC_LOG(INFO, TAG, "In SecurePortDiscoveryCallback");
 178
 179     if (!ctx ||
 180         !clientResponse ||
 181         !clientResponse->payload||
 182         (PAYLOAD_TYPE_DISCOVERY != clientResponse->payload->type)||
 183         (OC_STACK_OK != clientResponse->result))
 184     {
 185         OIC_LOG_V(ERROR, TAG, "%s Invalid Response ", __func__);
 186         SRMSendResponse(ACCESS_DENIED_AMS_SERVICE_ERROR);
 187         return OC_STACK_DELETE_TRANSACTION;
 188     }
 189
 190     PEContext_t *context = (PEContext_t *) ctx;
 191
 192     (void)handle;
 193     if (context->state != AWAITING_AMS_RESPONSE)
 194     {
 195         OIC_LOG_V(ERROR, TAG, "%s Invalid PE State ", __func__);
 196         context->retVal = ACCESS_DENIED_AMS_SERVICE_ERROR;
 197         SRMSendResponse(context->retVal);
 198         return OC_STACK_DELETE_TRANSACTION;
 199     }
 200
 201     OCResourcePayload* resPayload = ((OCDiscoveryPayload*)clientResponse->payload)->resources;
 202
 203     //Verifying if the ID of the sender is an AMS service that this device trusts.
 204     if(resPayload &&
 205        memcmp(context->amsMgrContext->amsDeviceId.id,
 206             ((OCDiscoveryPayload*)clientResponse->payload)->sid,
 207             // resPayload->sid,
 208                     sizeof(context->amsMgrContext->amsDeviceId.id)) != 0)
 209     {
 210         OIC_LOG_V(ERROR, TAG, "%s Invalid AMS device", __func__);
 211         context->retVal = ACCESS_DENIED_AMS_SERVICE_ERROR;
 212         SRMSendResponse(context->retVal);
 213         return OC_STACK_DELETE_TRANSACTION;
 214     }
 215
 216     if (resPayload && resPayload->secure)
 217     {
 218         if(OC_STACK_OK == SendAclReq(context, &clientResponse->devAddr, clientResponse->connType,
 219                 resPayload->port))
 220         {
 221             return OC_STACK_DELETE_TRANSACTION;
 222         }
 223     }
 224     OIC_LOG(INFO, TAG, "Can not find secure port information");
 225
 226     context->retVal = ACCESS_DENIED_AMS_SERVICE_ERROR;
 227     SRMSendResponse(context->retVal);
 228     return OC_STACK_DELETE_TRANSACTION;
 229 }
 230
 231
 232 OCStackResult SendAclReq(PEContext_t *context, OCDevAddr *devAddr, OCConnectivityType connType,
 233         uint16_t securedPort)
 234 {
 235     OCStackResult ret = OC_STACK_ERROR;
 236     const char GET_ACE_QUERY_FMT[] = "%s?%s=%s;%s=%s";
 237     char base64Buff[B64ENCODE_OUT_SAFESIZE(sizeof(((OicUuid_t*)0)->id)) + 1] = {};
 238     uint32_t outLen = 0;
 239     char uri[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {};
 240     OCCallbackData cbData = {.context=NULL};
 241     OCDevAddr destAddr = {.adapter = OC_ADAPTER_IP};
 242     B64Result b64Ret;
 243
 244     VERIFY_NON_NULL(TAG, context, ERROR);
 245     VERIFY_NON_NULL(TAG, devAddr, ERROR);
 246
 247     b64Ret = b64Encode(context->subject.id, sizeof(context->subject.id),
 248                        base64Buff, sizeof(base64Buff), &outLen);
 249     VERIFY_SUCCESS(TAG, B64_OK == b64Ret, ERROR);
 250
 251     snprintf(uri, sizeof(uri), GET_ACE_QUERY_FMT, OIC_RSRC_ACL_URI,
 252                                     OIC_JSON_SUBJECT_NAME, base64Buff,
 253                                     OIC_JSON_RESOURCES_NAME, context->resource);
 254
 255     cbData.cb = &AmsMgrAclReqCallback;
 256     cbData.context = context;
 257
 258     destAddr = *devAddr;
 259     //update port info
 260     destAddr.flags = (OCTransportFlags)(destAddr.flags | OC_FLAG_SECURE);
 261     destAddr.port = securedPort;
 262
 263     OIC_LOG_V(INFO, TAG, "AMS Manager Sending Unicast ACL request with URI = %s", uri);
 264     ret = OCDoResource(NULL, OC_REST_GET, uri, &destAddr, NULL,
 265             connType, OC_LOW_QOS, &cbData, NULL, 0);
 266
 267 exit:
 268     OIC_LOG_V(INFO, TAG, "%s returns %d ", __func__, ret);
 269     return ret;
 270 }
 271
 272
 273 static OCStackApplicationResult AmsMgrAclReqCallback(void *ctx, OCDoHandle handle,
 274     OCClientResponse * clientResponse)
 275 {
 276     OIC_LOG_V(INFO, TAG, "%s Begin", __func__ );
 277
 278     (void)handle;
 279     PEContext_t *context = (PEContext_t *) ctx;
 280     SRMAccessResponse_t rsps;
 281
 282     if (!ctx ||
 283         !clientResponse ||
 284         !clientResponse->payload||
 285         (PAYLOAD_TYPE_SECURITY != clientResponse->payload->type) ||
 286         (clientResponse->result != OC_STACK_OK))
 287     {
 288         OIC_LOG_V(ERROR, TAG, "%s Invalid Response ", __func__);
 289         SRMSendResponse(ACCESS_DENIED_AMS_SERVICE_ERROR);
 290         return OC_STACK_DELETE_TRANSACTION;
 291     }
 292
 293     if (context->state != AWAITING_AMS_RESPONSE)
 294     {
 295         OIC_LOG_V(ERROR, TAG, "%s Invalid State ", __func__);
 296         context->retVal = ACCESS_DENIED_AMS_SERVICE_ERROR;
 297         SRMSendResponse(context->retVal);
 298         return OC_STACK_DELETE_TRANSACTION;
 299     }
 300
 301     // Verify before installing ACL if the ID of the sender of this ACL is an AMS
 302     //service that this device trusts.
 303     rsps = ACCESS_DENIED;
 304     if((UUID_LENGTH == clientResponse->identity.id_length) &&
 305         memcmp(context->amsMgrContext->amsDeviceId.id, clientResponse->identity.id,
 306                        sizeof(context->amsMgrContext->amsDeviceId.id)) == 0)
 307     {
 308         OCStackResult ret =
 309                 InstallNewACL(((OCSecurityPayload*)clientResponse->payload)->securityData);
 310         VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
 311
 312         OIC_LOG_V(INFO, TAG, "%s : Calling checkPermission", __func__);
 313         rsps = CheckPermission(context, &context->subject, context->resource, context->permission);
 314         VERIFY_SUCCESS(TAG, (true == IsAccessGranted(rsps)), ERROR);
 315
 316         OIC_LOG_V(INFO, TAG, "%sAccess granted, Calling SRMCallCARequestHandler", __func__);
 317         context->retVal = ACCESS_GRANTED;
 318         SRMSendResponse(context->retVal);
 319         return OC_STACK_DELETE_TRANSACTION;
 320     }
 321
 322 exit:
 323     context->retVal = ACCESS_DENIED_AMS_SERVICE_ERROR;
 324     SRMSendResponse(context->retVal);
 325     return OC_STACK_DELETE_TRANSACTION;
 326 }
 327
 328
 329 OCStackResult UpdateAmsMgrContext(PEContext_t *context, const CAEndpoint_t *endpoint,
 330                         const CARequestInfo_t *requestInfo)
 331 {
 332     OCStackResult ret = OC_STACK_ERROR;
 333
 334     //The AmsMgr context endpoint and requestInfo will be free from ,
 335     //AmsMgrAclReqCallback function
 336     if(context->amsMgrContext->endpoint)
 337     {
 338         OICFree(context->amsMgrContext->endpoint);
 339         context->amsMgrContext->endpoint = NULL;
 340     }
 341     context->amsMgrContext->endpoint = (CAEndpoint_t *)OICCalloc(1, sizeof(CAEndpoint_t ));
 342     VERIFY_NON_NULL(TAG, context->amsMgrContext->endpoint, ERROR);
 343     *context->amsMgrContext->endpoint = *endpoint;
 344
 345     if(context->amsMgrContext->requestInfo)
 346     {
 347         FreeCARequestInfo(context->amsMgrContext->requestInfo);
 348         context->amsMgrContext->requestInfo = NULL;
 349     }
 350     context->amsMgrContext->requestInfo = CACloneRequestInfo(requestInfo);
 351     VERIFY_NON_NULL(TAG, context->amsMgrContext->requestInfo, ERROR);
 352     ret = OC_STACK_OK;
 353 exit:
 354     return ret;
 355 }
 356
 357 void FreeCARequestInfo(CARequestInfo_t *requestInfo)
 358 {
 359     if(NULL == requestInfo)
 360     {
 361         OIC_LOG_V(ERROR, TAG, "%s: Can't free memory. Received NULL requestInfo", __func__);
 362         return;
 363     }
 364     OICFree(requestInfo->info.token);
 365     OICFree(requestInfo->info.options);
 366     OICFree(requestInfo->info.payload);
 367     OICFree(requestInfo->info.resourceUri);
 368     OICFree(requestInfo);
 369 }
 370
 371
 372 //This method checks for Amacl resource. If Amacl is found then it fills up
 373 //context->amsMgrContext->amsDeviceId with amsID of the Amacl else leaves it empty.
 374 bool FoundAmaclForRequest(PEContext_t *context)
 375 {
 376     OIC_LOG_V(INFO, TAG, "%s:no ACL found. Searching for AMACL",__func__);
 377
 378     bool ret = false;
 379     VERIFY_NON_NULL(TAG, context, ERROR);
 380     memset(&context->amsMgrContext->amsDeviceId, 0, sizeof(context->amsMgrContext->amsDeviceId));
 381
 382     //Call amacl resource function to get the AMS service deviceID for the resource
 383     if(OC_STACK_OK == AmaclGetAmsDeviceId(context->resource, &context->amsMgrContext->amsDeviceId))
 384     {
 385         OIC_LOG_V(INFO, TAG, "%s:AMACL found for the requested resource %s",
 386                 __func__, context->resource);
 387         ret = true;
 388     }
 389     else
 390     {
 391         OIC_LOG_V(INFO, TAG, "%s:AMACL found for the requested resource %s",
 392                 __func__, context->resource);
 393         ret = false;
 394     }
 395
 396  exit:
 397      return ret;
 398 }
 399
 400
 401 void ProcessAMSRequest(PEContext_t *context)
 402 {
 403     OicUuid_t  emptyUuid = {.id={}};
 404     OIC_LOG_V(INFO, TAG, "Entering %s", __func__);
 405     if(NULL != context)
 406     {
 407         if((false == context->matchingAclFound) && (false == context->amsProcessing))
 408         {
 409             context->amsProcessing = true;
 410
 411             //Checking if context AMS deviceId is empty
 412             if(memcmp(&context->amsMgrContext->amsDeviceId, &emptyUuid, sizeof(OicUuid_t)) != 0 )
 413             {
 414                 if(OC_STACK_OK == DiscoverAmsService(context))
 415                 {
 416                     context->retVal = ACCESS_WAITING_FOR_AMS;
 417                     OIC_LOG_V(INFO, TAG, "Leaving %s(WAITING_FOR_AMS)", __func__);
 418                     context->state = AWAITING_AMS_RESPONSE;
 419                 }
 420                 else
 421                 {
 422                     context->retVal = ACCESS_DENIED_AMS_SERVICE_ERROR;
 423                 }
 424             }
 425         }
 426     }
 427     else
 428     {
 429         OIC_LOG_V(INFO, TAG, "Leaving %s(context is NULL)", __func__);
 430     }
 431 }