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     OC_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     OC_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     OC_LOG(INFO, TAG, "Leaving DiscoverAmsService");
  89     return ret;
  90 }
  91
  92
  93 static OCStackApplicationResult AmsMgrDiscoveryCallback(void *ctx, OCDoHandle handle,
  94                          OCClientResponse * clientResponse)
  95 {
  96     OC_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         OC_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         OC_LOG_V(ERROR, TAG, "%s Invalid PE State ", __func__);
 113         return OC_STACK_DELETE_TRANSACTION;
 114     }
 115
 116     OicSecDoxm_t *doxm = NULL;
 117     OC_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         OC_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         OC_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     OC_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     OC_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     OC_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             OC_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     (void)handle;
 192     if (context->state != AWAITING_AMS_RESPONSE)
 193     {
 194         OC_LOG_V(ERROR, TAG, "%s Invalid PE State ", __func__);
 195         context->retVal = ACCESS_DENIED_AMS_SERVICE_ERROR;
 196         SRMSendResponse(context->retVal);
 197         return OC_STACK_DELETE_TRANSACTION;
 198     }
 199     OCResourcePayload* resPayload = ((OCDiscoveryPayload*)clientResponse->payload)->resources;
 200
 201     //Verifying if the ID of the sender is an AMS service that this device trusts.
 202     if(resPayload &&
 203        memcmp(context->amsMgrContext->amsDeviceId.id, resPayload->sid,
 204                     sizeof(context->amsMgrContext->amsDeviceId.id)) != 0)
 205     {
 206         context->retVal = ACCESS_DENIED_AMS_SERVICE_ERROR;
 207         SRMSendResponse(context->retVal);
 208         return OC_STACK_DELETE_TRANSACTION;
 209     }
 210
 211     if (resPayload && resPayload->secure)
 212     {
 213         if(OC_STACK_OK == SendAclReq(context, &clientResponse->devAddr, clientResponse->connType,
 214                 resPayload->port))
 215         {
 216             return OC_STACK_DELETE_TRANSACTION;
 217         }
 218     }
 219     OC_LOG(INFO, TAG, "Can not find secure port information");
 220     context->retVal = ACCESS_DENIED_AMS_SERVICE_ERROR;
 221     SRMSendResponse(context->retVal);
 222     return OC_STACK_DELETE_TRANSACTION;
 223 }
 224
 225
 226 OCStackResult SendAclReq(PEContext_t *context, OCDevAddr *devAddr, OCConnectivityType connType,
 227         uint16_t securedPort)
 228 {
 229     OCStackResult ret = OC_STACK_ERROR;
 230     const char GET_ACE_QUERY_FMT[] = "%s?%s=%s;%s=%s";
 231     char base64Buff[B64ENCODE_OUT_SAFESIZE(sizeof(((OicUuid_t*)0)->id)) + 1] = {};
 232     uint32_t outLen = 0;
 233     char uri[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {};
 234     OCCallbackData cbData = {.context=NULL};
 235     OCDevAddr destAddr = {.adapter = OC_ADAPTER_IP};
 236     B64Result b64Ret;
 237
 238     VERIFY_NON_NULL(TAG, context, ERROR);
 239     VERIFY_NON_NULL(TAG, devAddr, ERROR);
 240
 241     b64Ret = b64Encode(context->subject.id, sizeof(context->subject.id),
 242                        base64Buff, sizeof(base64Buff), &outLen);
 243     VERIFY_SUCCESS(TAG, B64_OK == b64Ret, ERROR);
 244
 245     snprintf(uri, sizeof(uri), GET_ACE_QUERY_FMT, OIC_RSRC_ACL_URI,
 246                                     OIC_JSON_SUBJECT_NAME, base64Buff,
 247                                     OIC_JSON_RESOURCES_NAME, context->resource);
 248
 249     cbData.cb = &AmsMgrAclReqCallback;
 250     cbData.context = context;
 251
 252     destAddr = *devAddr;
 253     //update port info
 254     destAddr.flags = (OCTransportFlags)(destAddr.flags | OC_FLAG_SECURE);
 255     destAddr.port = securedPort;
 256
 257     OC_LOG_V(INFO, TAG, "AMS Manager Sending Unicast ACL request with URI = %s", uri);
 258     ret = OCDoResource(NULL, OC_REST_GET, uri, &destAddr, NULL,
 259             connType, OC_LOW_QOS, &cbData, NULL, 0);
 260
 261 exit:
 262     OC_LOG_V(INFO, TAG, "%s returns %d ", __func__, ret);
 263     return ret;
 264 }
 265
 266
 267 static OCStackApplicationResult AmsMgrAclReqCallback(void *ctx, OCDoHandle handle,
 268     OCClientResponse * clientResponse)
 269 {
 270     OC_LOG_V(INFO, TAG, "%s Begin", __func__ );
 271
 272     (void)handle;
 273     PEContext_t *context = (PEContext_t *) ctx;
 274     SRMAccessResponse_t rsps;
 275
 276     if (!ctx ||
 277         !clientResponse ||
 278         !clientResponse->payload||
 279         (PAYLOAD_TYPE_SECURITY != clientResponse->payload->type) ||
 280         (clientResponse->result != OC_STACK_OK))
 281     {
 282         SRMSendResponse(ACCESS_DENIED_AMS_SERVICE_ERROR);
 283         goto exit;
 284     }
 285
 286     if (context->state != AWAITING_AMS_RESPONSE)
 287     {
 288         OC_LOG_V(ERROR, TAG, "%s Invalid State ", __func__);
 289         context->retVal = ACCESS_DENIED_AMS_SERVICE_ERROR;
 290         SRMSendResponse(context->retVal);
 291         return OC_STACK_DELETE_TRANSACTION;
 292     }
 293
 294     // Verify before installing ACL if the ID of the sender of this ACL is an AMS
 295     //service that this device trusts.
 296     rsps = ACCESS_DENIED;
 297     if((UUID_LENGTH == clientResponse->identity.id_length) &&
 298         memcmp(context->amsMgrContext->amsDeviceId.id, clientResponse->identity.id,
 299                        sizeof(context->amsMgrContext->amsDeviceId.id)) == 0)
 300     {
 301         OCStackResult ret =
 302                 InstallNewACL(((OCSecurityPayload*)clientResponse->payload)->securityData);
 303         VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
 304
 305         OC_LOG_V(INFO, TAG, "%s : Calling checkPermission", __func__);
 306         rsps = CheckPermission(context, &context->subject, context->resource, context->permission);
 307         VERIFY_SUCCESS(TAG, (true == IsAccessGranted(rsps)), ERROR);
 308
 309         OC_LOG_V(INFO, TAG, "%sAccess granted, Calling SRMCallCARequestHandler", __func__);
 310         context->retVal = ACCESS_GRANTED;
 311         SRMSendResponse(context->retVal);
 312         return OC_STACK_DELETE_TRANSACTION;
 313     }
 314
 315 exit:
 316     context->retVal = ACCESS_DENIED_AMS_SERVICE_ERROR;
 317     SRMSendResponse(context->retVal);
 318     FreeCARequestInfo(context->amsMgrContext->requestInfo);
 319     OICFree(context->amsMgrContext->endpoint);
 320     return OC_STACK_DELETE_TRANSACTION;
 321 }
 322
 323
 324 OCStackResult UpdateAmsMgrContext(PEContext_t *context, const CAEndpoint_t *endpoint,
 325                         const CARequestInfo_t *requestInfo)
 326 {
 327     OCStackResult ret = OC_STACK_ERROR;
 328
 329     //The AmsMgr context endpoint and requestInfo will be free from ,
 330     //AmsMgrAclReqCallback function
 331     if(context->amsMgrContext->endpoint)
 332     {
 333         OICFree(context->amsMgrContext->endpoint);
 334         context->amsMgrContext->endpoint = NULL;
 335     }
 336     context->amsMgrContext->endpoint = (CAEndpoint_t *)OICCalloc(1, sizeof(CAEndpoint_t ));
 337     VERIFY_NON_NULL(TAG, context->amsMgrContext->endpoint, ERROR);
 338     *context->amsMgrContext->endpoint = *endpoint;
 339
 340     if(context->amsMgrContext->requestInfo)
 341     {
 342         FreeCARequestInfo(context->amsMgrContext->requestInfo);
 343         context->amsMgrContext->requestInfo = NULL;
 344     }
 345     context->amsMgrContext->requestInfo = CACloneRequestInfo(requestInfo);
 346     VERIFY_NON_NULL(TAG, context->amsMgrContext->requestInfo, ERROR);
 347     ret = OC_STACK_OK;
 348 exit:
 349     return ret;
 350 }
 351
 352 void FreeCARequestInfo(CARequestInfo_t *requestInfo)
 353 {
 354     OICFree(requestInfo->info.token);
 355     OICFree(requestInfo->info.options);
 356     OICFree(requestInfo->info.payload);
 357     OICFree(requestInfo->info.resourceUri);
 358     OICFree(requestInfo);
 359 }
 360
 361
 362 //This method checks for Amacl resource. If Amacl is found then it fills up
 363 //context->amsMgrContext->amsDeviceId with amsID of the Amacl else leaves it empty.
 364 bool FoundAmaclForRequest(PEContext_t *context)
 365 {
 366     OC_LOG_V(INFO, TAG, "%s:no ACL found. Searching for AMACL",__func__);
 367
 368     bool ret = false;
 369     VERIFY_NON_NULL(TAG, context, ERROR);
 370     memset(&context->amsMgrContext->amsDeviceId, 0, sizeof(context->amsMgrContext->amsDeviceId));
 371
 372     //Call amacl resource function to get the AMS service deviceID for the resource
 373     if(OC_STACK_OK == AmaclGetAmsDeviceId(context->resource, &context->amsMgrContext->amsDeviceId))
 374     {
 375         OC_LOG_V(INFO, TAG, "%s:AMACL found for the requested resource %s",
 376                 __func__, context->resource);
 377         ret = true;
 378     }
 379     else
 380     {
 381         OC_LOG_V(INFO, TAG, "%s:AMACL found for the requested resource %s",
 382                 __func__, context->resource);
 383         ret = false;
 384     }
 385
 386  exit:
 387      return ret;
 388 }
 389
 390
 391 void ProcessAMSRequest(PEContext_t *context)
 392 {
 393     OicUuid_t  emptyUuid = {.id={}};
 394     OC_LOG_V(INFO, TAG, "Entering %s", __func__);
 395     if(NULL != context)
 396     {
 397         if((false == context->matchingAclFound) && (false == context->amsProcessing))
 398         {
 399             context->amsProcessing = true;
 400
 401             //Checking if context AMS deviceId is empty
 402             if(memcmp(&context->amsMgrContext->amsDeviceId, &emptyUuid, sizeof(OicUuid_t)) != 0 )
 403             {
 404                 if(OC_STACK_OK == DiscoverAmsService(context))
 405                 {
 406                     context->retVal = ACCESS_WAITING_FOR_AMS;
 407                 }
 408                 else
 409                 {
 410                     context->retVal = ACCESS_DENIED_AMS_SERVICE_ERROR;
 411                 }
 412             }
 413         }
 414     }
 415     else
 416     {
 417         OC_LOG_V(INFO, TAG, "Leaving %s(context is NULL)", __func__);
 418     }
 419
 420     if(ACCESS_WAITING_FOR_AMS == context->retVal )
 421     {
 422         OC_LOG_V(INFO, TAG, "Leaving %s(WAITING_FOR_AMS)", __func__);
 423     }
 424 }