resource/csdk/security/src/crlresource.c

   1 //******************************************************************
   2 //
   3 // Copyright 2015 Samsung Electronics 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 "utlist.h"
  22 #include "payload_logging.h"
  23 #include "psinterface.h"
  24 #include "resourcemanager.h"
  25 #include "srmresourcestrings.h"
  26 #include "srmutility.h"
  27 #include "doxmresource.h"
  28 #include "ocpayload.h"
  29 #include "oic_malloc.h"
  30 #ifdef __WITH_X509__
  31 #include "crlresource.h"
  32 #include "crl.h"
  33 #endif /* __WITH_X509__ */
  34
  35 #define TAG  "SRM-CRL"
  36
  37 #define SEPARATOR                   ":"
  38 #define SEPARATOR_LEN               (1)
  39 #define CBOR_CRL_NAME               "\"CRL\""
  40 #define CBOR_CRL_NAME_LEN           (5)
  41 #define OIC_CBOR_CRL_NAME           "crl"
  42 #define OIC_CBOR_CRL_ID             "CRLId"
  43 #define OIC_CBOR_CRL_THIS_UPDATE    "ThisUpdate"
  44 #define OIC_CBOR_CRL_DATA           "CRLData"
  45 #define CRL_DEFAULT_CRL_ID          (1)
  46 #define CRL_DEFAULT_THIS_UPDATE     "150101000000Z"
  47 #define CRL_DEFAULT_CRL_DATA        "-"
  48
  49 static OCResourceHandle     gCrlHandle  = NULL;
  50 static OicSecCrl_t         *gCrl        = NULL;
  51
  52 /** Default cbor payload size. This value is increased in case of CborErrorOutOfMemory.
  53  * The value of payload size is increased until reaching below max cbor size. */
  54 static const uint16_t CBOR_SIZE = 1024;
  55
  56 // Max cbor size payload.
  57 static const uint16_t CBOR_MAX_SIZE = 4400;
  58
  59 // PSTAT Map size - Number of mandatory items
  60 static const uint8_t CRL_MAP_SIZE = 3;
  61
  62 void DeleteCrlBinData(OicSecCrl_t *crl)
  63 {
  64     if (crl)
  65     {
  66         //Clean ThisUpdate
  67         OICFree(crl->ThisUpdate.data);
  68
  69         //clean CrlData
  70         OICFree(crl->CrlData.data);
  71
  72         //Clean crl itself
  73         OICFree(crl);
  74     }
  75 }
  76
  77 OCStackResult CrlToCBORPayload(const OicSecCrl_t *crl, uint8_t **payload, size_t *size)
  78 {
  79     if (NULL == crl || NULL == payload || NULL != *payload || NULL == size)
  80     {
  81         return OC_STACK_INVALID_PARAM;
  82     }
  83
  84     size_t cborLen = *size;
  85     if (0 == cborLen)
  86     {
  87         cborLen = CBOR_SIZE;
  88     }
  89
  90     *payload = NULL;
  91     *size = 0;
  92
  93     OCStackResult ret = OC_STACK_ERROR;
  94
  95     CborEncoder encoder = { {.ptr = NULL }, .end = 0 };
  96     CborEncoder crlMap = { {.ptr = NULL }, .end = 0 };
  97
  98     CborError cborEncoderResult = CborNoError;
  99
 100     uint8_t *outPayload = (uint8_t *)OICCalloc(1, cborLen);
 101     VERIFY_NON_NULL(TAG, outPayload, ERROR);
 102     cbor_encoder_init(&encoder, outPayload, cborLen, 0);
 103
 104     cborEncoderResult = cbor_encoder_create_map(&encoder, &crlMap, CRL_MAP_SIZE);
 105     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, ERROR);
 106
 107     //CRLId -- Mandatory
 108     cborEncoderResult = cbor_encode_text_string(&crlMap, OIC_CBOR_CRL_ID,
 109         strlen(OIC_CBOR_CRL_ID));
 110     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, ERROR);
 111     cborEncoderResult = cbor_encode_int(&crlMap, crl->CrlId);
 112     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, ERROR);
 113
 114     //ThisUpdate -- Mandatory
 115     cborEncoderResult = cbor_encode_text_string(&crlMap, OIC_CBOR_CRL_THIS_UPDATE,
 116         strlen(OIC_CBOR_CRL_THIS_UPDATE));
 117     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, ERROR);
 118     cborEncoderResult = cbor_encode_byte_string(&crlMap, crl->ThisUpdate.data,
 119                                                 crl->ThisUpdate.len);
 120     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, ERROR);
 121
 122     //CRLData -- Mandatory
 123     cborEncoderResult = cbor_encode_text_string(&crlMap, OIC_CBOR_CRL_DATA,
 124         strlen(OIC_CBOR_CRL_DATA));
 125     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, ERROR);
 126     cborEncoderResult = cbor_encode_byte_string(&crlMap, crl->CrlData.data,
 127                                                 crl->CrlData.len);
 128     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, ERROR);
 129
 130     cborEncoderResult = cbor_encoder_close_container(&encoder, &crlMap);
 131     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, ERROR);
 132
 133     *size = encoder.ptr - outPayload;
 134     *payload = outPayload;
 135     ret = OC_STACK_OK;
 136
 137 exit:
 138     if ((CborErrorOutOfMemory == cborEncoderResult) && (cborLen < CBOR_MAX_SIZE))
 139     {
 140         // reallocate and try again!
 141         OICFree(outPayload);
 142         // Since the allocated initial memory failed, double the memory.
 143         cborLen += encoder.ptr - encoder.end;
 144         cborEncoderResult = CborNoError;
 145         ret = CrlToCBORPayload(crl, payload, &cborLen);
 146     }
 147
 148     if ((CborNoError != cborEncoderResult) || (OC_STACK_OK != ret))
 149     {
 150         OICFree(outPayload);
 151         outPayload = NULL;
 152         *payload = NULL;
 153         *size = 0;
 154         ret = OC_STACK_ERROR;
 155     }
 156
 157     return ret;
 158 }
 159
 160 OCStackResult CBORPayloadToCrl(const uint8_t *cborPayload, const size_t size,
 161                                OicSecCrl_t **secCrl)
 162 {
 163     if (NULL == cborPayload || NULL == secCrl || NULL != *secCrl)
 164     {
 165         return OC_STACK_INVALID_PARAM;
 166     }
 167
 168     OCStackResult ret = OC_STACK_ERROR;
 169     *secCrl = NULL;
 170
 171     CborValue crlCbor = {.parser = NULL};
 172     CborParser parser = {.end = NULL};
 173     CborError cborFindResult = CborNoError;
 174     int cborLen = (size == 0) ? CBOR_SIZE : size;
 175     cbor_parser_init(cborPayload, cborLen, 0, &parser, &crlCbor);
 176     CborValue crlMap = { .parser = NULL};
 177     OicSecCrl_t *crl = NULL;
 178     size_t outLen = 0;
 179     cborFindResult = cbor_value_enter_container(&crlCbor, &crlMap);
 180     VERIFY_CBOR_SUCCESS(TAG, cborFindResult, ERROR);
 181
 182     crl = (OicSecCrl_t *)OICCalloc(1, sizeof(OicSecCrl_t));
 183     VERIFY_NON_NULL(TAG, crl, ERROR);
 184
 185     cborFindResult = cbor_value_map_find_value(&crlCbor, OIC_CBOR_CRL_ID, &crlMap);
 186     if (CborNoError == cborFindResult && cbor_value_is_integer(&crlMap))
 187     {
 188         cborFindResult = cbor_value_get_int(&crlMap, (int *) &crl->CrlId);
 189         VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding CrlId.");
 190     }
 191
 192     cborFindResult = cbor_value_map_find_value(&crlCbor, OIC_CBOR_CRL_THIS_UPDATE, &crlMap);
 193     if (CborNoError == cborFindResult && cbor_value_is_byte_string(&crlMap))
 194     {
 195         cborFindResult = cbor_value_dup_byte_string(&crlMap,
 196             &crl->ThisUpdate.data, &crl->ThisUpdate.len, NULL);
 197         VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing Byte Array.");
 198     }
 199     cborFindResult = cbor_value_map_find_value(&crlCbor, OIC_CBOR_CRL_DATA, &crlMap);
 200     if (CborNoError == cborFindResult && cbor_value_is_byte_string(&crlMap))
 201     {
 202         cborFindResult = cbor_value_dup_byte_string(&crlMap,
 203                          &crl->CrlData.data, &crl->CrlData.len, NULL);
 204         VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing Byte Array.");
 205     }
 206
 207     *secCrl = crl;
 208     ret = OC_STACK_OK;
 209 exit:
 210     if (CborNoError != cborFindResult)
 211     {
 212         // PUT/POST CBOR may not have mandatory values set default values.
 213         if (gCrl)
 214         {
 215             OIC_LOG (DEBUG, TAG, "Set default values");
 216             crl->CrlId = gCrl->CrlId;
 217             if (crl->ThisUpdate.data)
 218             {
 219                 OICFree(crl->ThisUpdate.data);
 220             }
 221             outLen = gCrl->ThisUpdate.len;
 222             crl->ThisUpdate.data = (uint8_t*) OICMalloc(outLen);
 223             if (crl->ThisUpdate.data)
 224             {
 225                 memcpy(crl->ThisUpdate.data, gCrl->ThisUpdate.data, outLen);
 226                 crl->ThisUpdate.len = outLen;
 227             }
 228             else
 229             {
 230                 crl->ThisUpdate.len = 0;
 231                 OIC_LOG(ERROR, TAG, "Set default failed");
 232             }
 233             if (crl->CrlData.data)
 234             {
 235                 OICFree(crl->CrlData.data);
 236             }
 237             outLen = gCrl->CrlData.len;
 238             crl->CrlData.data = (uint8_t*) OICMalloc(outLen);
 239             if (crl->CrlData.data && gCrl->CrlData.data)
 240             {
 241                 memcpy(crl->CrlData.data, gCrl->CrlData.data, outLen);
 242                 crl->CrlData.len = outLen;
 243             }
 244             else
 245             {
 246                 crl->CrlData.len = 0;
 247                 OIC_LOG (ERROR, TAG, "Set default failed");
 248             }
 249
 250             *secCrl = crl;
 251             ret = OC_STACK_OK;
 252         }
 253         else
 254         {
 255             OIC_LOG (ERROR, TAG, "CBORPayloadToCrl failed");
 256             DeleteCrlBinData(crl);
 257             crl = NULL;
 258             ret = OC_STACK_ERROR;
 259         }
 260     }
 261     return ret;
 262 }
 263
 264 OCStackResult UpdateCRLResource(const OicSecCrl_t *crl)
 265 {
 266     uint8_t *payload = NULL;
 267     size_t size = 0;
 268
 269     OCStackResult res = CrlToCBORPayload((OicSecCrl_t *) crl, &payload, &size);
 270     if (OC_STACK_OK != res)
 271     {
 272         return res;
 273     }
 274
 275     return UpdateSecureResourceInPS(OIC_CBOR_CRL_NAME, payload, size);
 276 }
 277
 278 static OCEntityHandlerResult HandleCRLPostRequest(const OCEntityHandlerRequest *ehRequest)
 279 {
 280     OCEntityHandlerResult ehRet = OC_EH_ERROR;
 281     OicSecCrl_t *crl = NULL;
 282     uint8_t *payload = ((OCSecurityPayload *)ehRequest->payload)->securityData1;
 283     size_t size = ((OCSecurityPayload *) ehRequest->payload)->payloadSize;
 284
 285     if (payload)
 286     {
 287         OIC_LOG(INFO, TAG, "UpdateSVRDB...");
 288         CBORPayloadToCrl(payload, size, &crl);
 289         VERIFY_NON_NULL(TAG, crl, ERROR);
 290
 291         gCrl->CrlId = crl->CrlId;
 292
 293         OICFree(gCrl->ThisUpdate.data);
 294         gCrl->ThisUpdate.data = NULL;
 295         gCrl->ThisUpdate.data = OICMalloc(crl->ThisUpdate.len);
 296         VERIFY_NON_NULL(TAG, gCrl->ThisUpdate.data, ERROR);
 297         memcpy(gCrl->ThisUpdate.data, crl->ThisUpdate.data, crl->ThisUpdate.len);
 298         gCrl->ThisUpdate.len = crl->ThisUpdate.len;
 299
 300         OICFree(gCrl->CrlData.data);
 301         gCrl->CrlData.data = OICMalloc(crl->CrlData.len);
 302         VERIFY_NON_NULL(TAG, gCrl->CrlData.data, ERROR);
 303         memcpy(gCrl->CrlData.data, crl->CrlData.data, crl->CrlData.len);
 304         gCrl->CrlData.len = crl->CrlData.len;
 305
 306         if (OC_STACK_OK == UpdateSecureResourceInPS(OIC_CBOR_CRL_NAME, payload, size))
 307         {
 308             ehRet = OC_EH_RESOURCE_CREATED;
 309         }
 310
 311         DeleteCrlBinData(crl);
 312         OICFree(payload);
 313     }
 314
 315 exit:
 316     // Send payload to request originator
 317     SendSRMCBORResponse(ehRequest, ehRet, NULL, 0);
 318
 319     OIC_LOG_V(INFO, TAG, "%s RetVal %d", __func__, ehRet);
 320     return ehRet;
 321 }
 322
 323
 324 /**
 325  * This internal method is the entity handler for CRL resource and
 326  * will handle REST request (GET/PUT/POST/DEL) for them.
 327  */
 328 static OCEntityHandlerResult CRLEntityHandler(OCEntityHandlerFlag flag,
 329                                               OCEntityHandlerRequest *ehRequest,
 330                                               void *callbackParameter)
 331 {
 332     OCEntityHandlerResult ehRet = OC_EH_ERROR;
 333     (void)callbackParameter;
 334
 335     if (!ehRequest)
 336     {
 337         return ehRet;
 338     }
 339
 340     OIC_LOG(INFO, TAG, "Handle CRL resource");
 341
 342     if (flag & OC_REQUEST_FLAG)
 343     {
 344         // TODO :  Handle PUT and DEL methods
 345         OIC_LOG (INFO, TAG, "Flag includes OC_REQUEST_FLAG");
 346         switch (ehRequest->method)
 347         {
 348             case OC_REST_GET:
 349                 OIC_LOG (INFO, TAG, "Not implemented request method.");
 350                 //ehRet = HandleCRLGetRequest(ehRequest);
 351                 break;
 352
 353             case OC_REST_POST:
 354                 ehRet = HandleCRLPostRequest(ehRequest);
 355                 break;
 356
 357             default:
 358                 ehRet = OC_EH_ERROR;
 359                 SendSRMCBORResponse(ehRequest, ehRet, NULL, 0);
 360         }
 361     }
 362
 363     return ehRet;
 364 }
 365
 366 /**
 367  * This internal method is used to create '/oic/sec/crl' resource.
 368  */
 369 static OCStackResult CreateCRLResource()
 370 {
 371     OCStackResult ret = OCCreateResource(&gCrlHandle,
 372                                          OIC_RSRC_TYPE_SEC_CRL,
 373                                          OIC_MI_DEF,
 374                                          OIC_RSRC_CRL_URI,
 375                                          CRLEntityHandler,
 376                                          NULL,
 377                                          OC_OBSERVABLE);
 378
 379     if (OC_STACK_OK != ret)
 380     {
 381         OIC_LOG(FATAL, TAG, "Unable to instantiate CRL resource");
 382         DeInitCRLResource();
 383     }
 384     return ret;
 385 }
 386
 387 /**
 388  * Get the default value.
 389  * @return defaultCrl for now.
 390  */
 391 static OicSecCrl_t *GetCrlDefault()
 392 {
 393     OicSecCrl_t *defaultCrl = (OicSecCrl_t *)OICCalloc(1, sizeof(OicSecCrl_t));
 394     if (NULL == defaultCrl)
 395     {
 396         return NULL;
 397     }
 398     defaultCrl->CrlId = CRL_DEFAULT_CRL_ID;
 399
 400     defaultCrl->CrlData.len = strlen(CRL_DEFAULT_CRL_DATA);
 401     defaultCrl->CrlData.data = (uint8_t*) OICMalloc(defaultCrl->CrlData.len);
 402     if (defaultCrl->CrlData.data)
 403     {
 404         memcpy(defaultCrl->CrlData.data, CRL_DEFAULT_CRL_DATA, defaultCrl->CrlData.len);
 405     }
 406     else
 407     {
 408         defaultCrl->CrlData.len = 0;
 409     }
 410
 411     defaultCrl->ThisUpdate.len = strlen(CRL_DEFAULT_THIS_UPDATE);
 412     defaultCrl->ThisUpdate.data = (uint8_t*) OICMalloc(defaultCrl->ThisUpdate.len);
 413     if (defaultCrl->ThisUpdate.data)
 414     {
 415         memcpy(defaultCrl->ThisUpdate.data, CRL_DEFAULT_THIS_UPDATE, defaultCrl->ThisUpdate.len);
 416     }
 417     else
 418     {
 419         defaultCrl->ThisUpdate.len = 0;
 420     }
 421
 422     return defaultCrl;
 423 }
 424
 425 /**
 426  * Initialize CRL resource by loading data from persistent storage.
 427  *
 428  * @retval
 429  *     OC_STACK_OK    - no errors
 430  *     OC_STACK_ERROR - stack process error
 431  */
 432 OCStackResult InitCRLResource()
 433 {
 434     OCStackResult ret = OC_STACK_ERROR;
 435     // Read Crl resource from PS
 436     uint8_t *data = NULL;
 437     size_t size = 0;
 438     ret = GetSecureVirtualDatabaseFromPS(OIC_CBOR_CRL_NAME, &data, &size);
 439     // If database read failed
 440     if (OC_STACK_OK != ret)
 441     {
 442         OIC_LOG (DEBUG, TAG, "ReadSVDataFromPS failed");
 443     }
 444     if (data)
 445     {
 446         // Read ACL resource from PS
 447         ret = CBORPayloadToCrl(data, size, &gCrl);
 448     }
 449
 450     /*
 451      * If SVR database in persistent storage got corrupted or
 452      * is not available for some reason, a default CrlResource is created
 453      * which allows user to initiate CrlResource provisioning again.
 454      */
 455     if ((OC_STACK_OK != ret) || !data || !gCrl)
 456     {
 457         gCrl = GetCrlDefault();
 458     }
 459
 460     ret = CreateCRLResource();
 461     OICFree(data);
 462     return ret;
 463 }
 464
 465 /**
 466  * Perform cleanup for ACL resources.
 467  */
 468 void DeInitCRLResource()
 469 {
 470     OCDeleteResource(gCrlHandle);
 471     gCrlHandle = NULL;
 472     DeleteCrlBinData(gCrl);
 473     gCrl = NULL;
 474 }
 475
 476 OicSecCrl_t *GetCRLResource()
 477 {
 478     OicSecCrl_t *crl =  NULL;
 479
 480     //Read CRL resource from PS
 481     uint8_t *data = NULL;
 482     size_t size = 0;
 483     OCStackResult ret = GetSecureVirtualDatabaseFromPS(OIC_CBOR_CRL_NAME, &data, &size);
 484     if (data)
 485     {
 486         //Convert CBOR CRL into binary format
 487         ret = CBORPayloadToCrl(data, size, &crl);
 488     }
 489     /*
 490      * If SVR database in persistent storage got corrupted or
 491      * is not available for some reason, a default CrlResource is created
 492      * which allows user to initiate CrlResource provisioning again.
 493      */
 494     if ((OC_STACK_OK != ret) || !data || !crl)
 495     {
 496         crl = GetCrlDefault();
 497     }
 498     OICFree(data);
 499
 500     return crl;
 501 }
 502
 503 uint8_t *GetCrl()
 504 {
 505     uint8_t *data = NULL;
 506     size_t size = 0;
 507     OicSecCrl_t *crl = NULL;
 508     if (OC_STACK_OK == GetSecureVirtualDatabaseFromPS(OIC_CBOR_CRL_NAME, &data, &size) && data &&
 509         OC_STACK_OK == CBORPayloadToCrl(data, size, &crl))
 510     {
 511         return crl->CrlData.data;
 512     }
 513     return NULL;
 514 }
 515
 516 void  GetDerCrl(ByteArray crlArray)
 517 {
 518     OicSecCrl_t * crlRes = GetCRLResource();
 519     if (crlRes && crlRes->CrlData.len <= crlArray.len)
 520     {
 521         memcpy(crlArray.data, crlRes->CrlData.data, crlRes->CrlData.len);
 522         crlArray.len = crlRes->CrlData.len;
 523     }
 524     else
 525     {
 526         crlArray.len = 0;
 527     }
 528     DeleteCrlBinData(crlRes);
 529 }