resource/csdk/security/provisioning/ck_manager/src/ckm_info.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  *      LICENSE-2.0" target="_blank">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
  22
  23 #include "ckm_info.h"
  24 #include "ocstack.h"
  25 #include "oic_malloc.h"
  26 #include "cJSON.h"
  27 #include "base64.h"
  28 #include "psinterface.h"
  29 #include "srmresourcestrings.h"
  30 #include "crlresource.h"
  31 #include "crl_generator.h"
  32
  33 //constants used in ckmInfo
  34 #define CKM_INFO_IS_NOT_LOADED                       (0)
  35 #define CKM_INFO_IS_LOADED                           (1)
  36 #define CA_PRIVATE_KEY_IS_NOT_SET                    (0)
  37 #define CA_PRIVATE_KEY_IS_SET                        (1)
  38 #define CA_PRIVATE_KEY_DEFAULT_VALUE                 (0)
  39 #define CA_PUBLIC_KEY_IS_NOT_SET                     (0)
  40 #define CA_PUBLIC_KEY_IS_SET                         (1)
  41 #define CA_PUBLIC_KEY_DEFAULT_VALUE                  (0)
  42 #define CA_CERTIFICATE_CHAIN_IS_NOT_SET              (0)
  43 #define CA_CERTIFICATE_CHAIN_MEMORY_IS_NOT_ALLOCATED (0)
  44 #define CA_NAME_IS_NOT_SET                           (0)
  45 #define CA_NAME_DEFAULT_VALUE                        (0)
  46 #define CERTIFICATE_SN_INITIAL_VALUE                 (1)
  47 #define CRL_SN_INITIAL_VALUE                         (1)
  48 #define NUMBER_OF_REVOKED_CERTIFICATES_INITIAL_VALUE (0)
  49
  50 //constants used in crlInfo
  51 #define CRL_IS_NOT_SET                               (0)
  52 #define CRL_MEMORY_IS_NOT_ALLOCATED                  (0)
  53
  54 static CKMInfo_t g_ckmInfo = {CKM_INFO_IS_NOT_LOADED,
  55                              CA_PRIVATE_KEY_IS_NOT_SET, {CA_PRIVATE_KEY_DEFAULT_VALUE},
  56                              CA_PUBLIC_KEY_IS_NOT_SET, {CA_PUBLIC_KEY_DEFAULT_VALUE},
  57                              CA_CERTIFICATE_CHAIN_IS_NOT_SET,
  58                              CA_CERTIFICATE_CHAIN_MEMORY_IS_NOT_ALLOCATED,
  59                              CA_NAME_IS_NOT_SET, {CA_NAME_DEFAULT_VALUE},
  60                              CERTIFICATE_SN_INITIAL_VALUE, CRL_SN_INITIAL_VALUE,
  61                              NUMBER_OF_REVOKED_CERTIFICATES_INITIAL_VALUE};
  62
  63 static OicSecCrl_t g_crlInfo = {CRL_IS_NOT_SET,
  64                                   BYTE_ARRAY_INITIALIZER, BYTE_ARRAY_INITIALIZER};
  65
  66 //General functions
  67
  68 PKIError InitCKMInfo(void)
  69 {
  70     FUNCTION_INIT();
  71     FILE *filePointer = NULL;
  72     int count = 1;
  73     int objectsRead = 0;
  74     int objectsWrote = 0;
  75
  76     if (!g_ckmInfo.CKMInfoIsLoaded)
  77     {
  78         filePointer = fopen(CA_STORAGE_FILE, "rb");
  79         if (filePointer) //read existing storage
  80         {
  81             objectsRead = fread(&g_ckmInfo, sizeof(CKMInfo_t), count, filePointer);
  82             g_ckmInfo.CACertificateChain = CA_CERTIFICATE_CHAIN_MEMORY_IS_NOT_ALLOCATED;
  83             CHECK_EQUAL(objectsRead, count, ISSUER_CA_STORAGE_FILE_READ_ERROR);
  84         }
  85         else ////create new storage
  86         {
  87             filePointer = fopen(CA_STORAGE_FILE, "wb");
  88             CHECK_NULL(filePointer, ISSUER_CA_STORAGE_FILE_WRITE_ERROR);
  89             objectsWrote = fwrite(&g_ckmInfo, sizeof(CKMInfo_t), count, filePointer);
  90             CHECK_EQUAL(objectsWrote, count, ISSUER_CA_STORAGE_FILE_WRITE_ERROR);
  91         }
  92         CHECK_CALL(InitCRL);
  93         CHECK_CALL(InitCRT);
  94         g_ckmInfo.CKMInfoIsLoaded = CKM_INFO_IS_LOADED;
  95     }
  96     FUNCTION_CLEAR(
  97         if (filePointer)
  98         {
  99             fclose(filePointer);
 100             filePointer = NULL;
 101         }
 102     );
 103 }
 104
 105 PKIError SaveCKMInfo(void)
 106 {
 107     FUNCTION_INIT();
 108     FILE *filePointer = NULL;
 109     int count = 1;
 110     int objectsWrote = 0;
 111
 112     CHECK_COND(g_ckmInfo.CKMInfoIsLoaded, CKM_INFO_IS_NOT_INIT);
 113     filePointer = fopen(CA_STORAGE_FILE, "wb");
 114     CHECK_NULL(filePointer, ISSUER_CA_STORAGE_FILE_WRITE_ERROR);
 115     objectsWrote = fwrite(&g_ckmInfo, sizeof(CKMInfo_t), count, filePointer);
 116     CHECK_EQUAL(objectsWrote, count, ISSUER_CA_STORAGE_FILE_WRITE_ERROR);
 117     if ((g_crlInfo.CrlData.data)&&(g_crlInfo.CrlData.len))
 118     {
 119         CHECK_CALL(SaveCRL);
 120     }
 121     if (g_ckmInfo.CAChainLength)
 122     {
 123         CHECK_CALL(SaveCRT);
 124     }
 125     FUNCTION_CLEAR(
 126         if (filePointer)
 127         {
 128             fclose(filePointer);
 129             filePointer = NULL;
 130         }
 131     );
 132 }
 133
 134 PKIError CloseCKMInfo(void)
 135 {
 136     FUNCTION_INIT();
 137     CHECK_CALL(SaveCKMInfo);
 138     OICFree(g_crlInfo.CrlData.data);
 139     g_crlInfo.CrlData.data = CRL_MEMORY_IS_NOT_ALLOCATED;
 140     OICFree(g_crlInfo.ThisUpdate.data);
 141     g_crlInfo.ThisUpdate.data = CRL_MEMORY_IS_NOT_ALLOCATED;
 142     OICFree(g_ckmInfo.CACertificateChain);
 143     g_ckmInfo.CACertificateChain = CA_CERTIFICATE_CHAIN_MEMORY_IS_NOT_ALLOCATED;
 144     g_ckmInfo.CKMInfoIsLoaded = CKM_INFO_IS_NOT_LOADED;
 145     g_crlInfo.CrlId = CRL_IS_NOT_SET;
 146     FUNCTION_CLEAR();
 147 }
 148
 149 PKIError SetCKMInfo (const long *nextSN, const long *CRLSerialNumber,
 150                      const ByteArray *CAPrivateKey, const ByteArray *CAPublicKey,
 151                      const ByteArray *CAName)
 152 {
 153     FUNCTION_INIT();
 154     if (nextSN)
 155         CHECK_CALL(SetNextSerialNumber, nextSN);
 156     if (CRLSerialNumber)
 157         CHECK_CALL(SetCRLSerialNumber, CRLSerialNumber);
 158     if (CAPrivateKey)
 159         CHECK_CALL(SetCAPrivateKey, CAPrivateKey);
 160     if (CAPublicKey)
 161         CHECK_CALL(SetCAPublicKey, CAPublicKey);
 162     if (CAName)
 163         CHECK_CALL(SetCAName, CAName);
 164
 165     FUNCTION_CLEAR();
 166 }
 167
 168 PKIError GetCKMInfo (long *nextSN, long *CRLSerialNumber,
 169                      ByteArray *CAPrivateKey, ByteArray *CAPublicKey,
 170                      ByteArray *CAName)
 171 {
 172     FUNCTION_INIT();
 173     if (nextSN)
 174         CHECK_CALL(GetNextSerialNumber, nextSN);
 175     if (CRLSerialNumber)
 176         CHECK_CALL(GetCRLSerialNumber, CRLSerialNumber);
 177     if (CAPrivateKey)
 178         CHECK_CALL(GetCAPrivateKey, CAPrivateKey);
 179     if (CAPublicKey)
 180         CHECK_CALL(GetCAPublicKey, CAPublicKey);
 181     if (CAName)
 182         CHECK_CALL(GetCAName, CAName);
 183
 184     FUNCTION_CLEAR();
 185 }
 186
 187 /*Private Key*/
 188 PKIError SetCAPrivateKey (const ByteArray *CAPrivateKey)
 189 {
 190     FUNCTION_INIT();
 191     CHECK_NULL_BYTE_ARRAY_PTR(CAPrivateKey, ISSUER_CA_STORAGE_NULL_PASSED);
 192     CHECK_EQUAL(CAPrivateKey->len, PRIVATE_KEY_SIZE, ISSUER_CA_STORAGE_WRONG_PRIVATE_KEY_LEN);
 193     memcpy(g_ckmInfo.CAPrivateKey, CAPrivateKey->data, PRIVATE_KEY_SIZE);
 194     g_ckmInfo.CAPrivateKeyIsSet = CA_PRIVATE_KEY_IS_SET;
 195
 196     FUNCTION_CLEAR();
 197 }
 198
 199 PKIError GetCAPrivateKey (ByteArray *CAPrivateKey)
 200 {
 201     FUNCTION_INIT();
 202     CHECK_COND(g_ckmInfo.CAPrivateKeyIsSet, ISSUER_CA_STORAGE_PRIVATE_KEY_UNDEFINED);
 203     CHECK_NULL_BYTE_ARRAY_PTR(CAPrivateKey, ISSUER_CA_STORAGE_NULL_PASSED);
 204     memcpy(CAPrivateKey->data, g_ckmInfo.CAPrivateKey, PRIVATE_KEY_SIZE);
 205     CAPrivateKey->len = PRIVATE_KEY_SIZE;
 206
 207     FUNCTION_CLEAR();
 208 }
 209
 210 /*Public Key*/
 211 PKIError SetCAPublicKey (const ByteArray *CAPublicKey)
 212 {
 213     FUNCTION_INIT();
 214     CHECK_NULL_BYTE_ARRAY_PTR(CAPublicKey, ISSUER_CA_STORAGE_NULL_PASSED);
 215     CHECK_EQUAL(CAPublicKey->len, PUBLIC_KEY_SIZE, ISSUER_CA_STORAGE_WRONG_PUBLIC_KEY_LEN);
 216     memcpy(g_ckmInfo.CAPublicKey, CAPublicKey->data, PUBLIC_KEY_SIZE);
 217     g_ckmInfo.CAPublicKeyIsSet = CA_PUBLIC_KEY_IS_SET;
 218
 219     FUNCTION_CLEAR();
 220 }
 221
 222 PKIError GetCAPublicKey (ByteArray *CAPublicKey)
 223 {
 224     FUNCTION_INIT();
 225     CHECK_COND(g_ckmInfo.CAPublicKeyIsSet, ISSUER_CA_STORAGE_PUBLIC_KEY_UNDEFINED);
 226     CHECK_NULL_BYTE_ARRAY_PTR(CAPublicKey, ISSUER_CA_STORAGE_NULL_PASSED);
 227     memcpy(CAPublicKey->data, g_ckmInfo.CAPublicKey, PUBLIC_KEY_SIZE);
 228     CAPublicKey->len = PUBLIC_KEY_SIZE;
 229
 230     FUNCTION_CLEAR();
 231 }
 232
 233 /*CAName*/
 234 PKIError SetCAName (const ByteArray *CAName)
 235 {
 236     FUNCTION_INIT();
 237     CHECK_NULL_BYTE_ARRAY_PTR(CAName, ISSUER_CA_STORAGE_NULL_PASSED);
 238     CHECK_LESS_EQUAL(CAName->len, ISSUER_MAX_NAME_SIZE, ISSUER_CA_STORAGE_WRONG_CA_NAME_LEN);
 239     memcpy(g_ckmInfo.CAName, CAName->data, CAName->len);
 240     g_ckmInfo.CANameSize = CAName->len;
 241
 242     FUNCTION_CLEAR();
 243 }
 244
 245 PKIError GetCAName (ByteArray *CAName)
 246 {
 247     FUNCTION_INIT();
 248     CHECK_COND(g_ckmInfo.CANameSize, ISSUER_CA_STORAGE_CA_NAME_UNDEFINED);
 249     CHECK_NULL_BYTE_ARRAY_PTR(CAName, ISSUER_CA_STORAGE_NULL_PASSED);
 250     memcpy(CAName->data, g_ckmInfo.CAName, g_ckmInfo.CANameSize);
 251     CAName->len = g_ckmInfo.CANameSize;
 252
 253     FUNCTION_CLEAR();
 254 }
 255
 256 //Certificate-related functions
 257
 258 #define CERT_LEN_PREFIX (3)
 259 #define BYTE_SIZE (8) //bits
 260
 261 static void WriteCertPrefix(uint8_t *prefix, uint32_t certLen)
 262 {
 263     for (size_t i = 0; i < CERT_LEN_PREFIX; ++i)
 264     {
 265         prefix[i] = (certLen >> (BYTE_SIZE * (CERT_LEN_PREFIX - 1 - i))) & 0xFF;
 266     }
 267 }
 268
 269 static uint32_t ParseCertPrefix(uint8_t *prefix)
 270 {
 271     uint32_t res = 0;
 272     if(NULL != prefix)
 273     {
 274         for(int i=0; i < CERT_LEN_PREFIX; ++i)
 275         {
 276             res |= (((uint32_t) prefix[i]) << ((CERT_LEN_PREFIX - 1 -i) * BYTE_SIZE));
 277         }
 278     }
 279     return res;
 280 }
 281
 282 PKIError InitCRT(void)
 283 {
 284     FUNCTION_INIT();
 285     FILE *filePointer = NULL;
 286     uint32_t objectsRead = 0;
 287     uint8_t prefix[CERT_LEN_PREFIX] = {0};
 288
 289     if (g_ckmInfo.CAChainLength)
 290     {
 291         filePointer = fopen(CA_STORAGE_CRT_FILE, "rb");
 292         CHECK_NULL(filePointer, ISSUER_CA_STORAGE_CRT_READ_ERROR);
 293
 294         g_ckmInfo.CACertificateChain =
 295                     (ByteArray *)OICMalloc(sizeof(ByteArray) * g_ckmInfo.CAChainLength);
 296         CHECK_NULL(g_ckmInfo.CACertificateChain, ISSUER_CA_STORAGE_MEMORY_ALLOC_FAILED);
 297
 298         for (int i = 0; i < g_ckmInfo.CAChainLength; i++)
 299         {
 300             objectsRead = fread(prefix, sizeof(uint8_t), CERT_LEN_PREFIX, filePointer);
 301             CHECK_EQUAL(objectsRead, CERT_LEN_PREFIX, ISSUER_CA_STORAGE_CRT_READ_ERROR);
 302             g_ckmInfo.CACertificateChain[i].len = ParseCertPrefix(prefix);
 303
 304             g_ckmInfo.CACertificateChain[i].data =
 305                             (uint8_t *)OICMalloc(g_ckmInfo.CACertificateChain[i].len);
 306             CHECK_NULL(g_ckmInfo.CACertificateChain[i].data,
 307                        ISSUER_CA_STORAGE_MEMORY_ALLOC_FAILED);
 308             objectsRead = fread(g_ckmInfo.CACertificateChain[i].data, sizeof(uint8_t),
 309                                 g_ckmInfo.CACertificateChain[i].len, filePointer);
 310             CHECK_EQUAL(objectsRead, g_ckmInfo.CACertificateChain[i].len,
 311                         ISSUER_CA_STORAGE_CRT_READ_ERROR);
 312         }
 313     }
 314     FUNCTION_CLEAR(
 315         if (filePointer)
 316         {
 317             fclose(filePointer);
 318             filePointer = NULL;
 319         }
 320     );
 321 }
 322
 323 PKIError SaveCRT(void)
 324 {
 325     FUNCTION_INIT();
 326     FILE *filePointer = NULL;
 327     uint32_t objectsWrote = 0;
 328     uint8_t prefix[CERT_LEN_PREFIX] = {0};
 329
 330     filePointer = fopen(CA_STORAGE_CRT_FILE, "wb");
 331     CHECK_NULL(filePointer, ISSUER_CA_STORAGE_CRT_WRITE_ERROR);
 332
 333     for (int i = 0; i < g_ckmInfo.CAChainLength; i++)
 334     {
 335         WriteCertPrefix(prefix, g_ckmInfo.CACertificateChain[i].len);
 336         objectsWrote = fwrite(prefix, sizeof(uint8_t), CERT_LEN_PREFIX, filePointer);
 337         CHECK_EQUAL(objectsWrote, CERT_LEN_PREFIX, ISSUER_CA_STORAGE_CRT_WRITE_ERROR);
 338         objectsWrote = fwrite(g_ckmInfo.CACertificateChain[i].data, sizeof(uint8_t),
 339                               g_ckmInfo.CACertificateChain[i].len, filePointer);
 340         CHECK_EQUAL(objectsWrote, g_ckmInfo.CACertificateChain[i].len,
 341                     ISSUER_CA_STORAGE_CRT_WRITE_ERROR);
 342     }
 343
 344     FUNCTION_CLEAR(
 345         if (filePointer)
 346         {
 347             fclose(filePointer);
 348             filePointer = NULL;
 349         }
 350     );
 351 }
 352
 353 /*Serial Number*/
 354 PKIError SetNextSerialNumber (const long *nextSN)
 355 {
 356     FUNCTION_INIT();
 357     CHECK_NULL(nextSN, ISSUER_CA_STORAGE_NULL_PASSED);
 358     CHECK_LESS_EQUAL(0, *nextSN, ISSUER_CA_STORAGE_WRONG_SERIAL_NUMBER);
 359     g_ckmInfo.nextSerialNumber = *nextSN;
 360
 361     FUNCTION_CLEAR();
 362 }
 363
 364 PKIError GetNextSerialNumber (long *nextSN)
 365 {
 366     FUNCTION_INIT();
 367     CHECK_NULL(nextSN, ISSUER_CA_STORAGE_NULL_PASSED);
 368     CHECK_NULL(g_ckmInfo.nextSerialNumber, ISSUER_CA_STORAGE_SN_UNDEFINED);
 369     *nextSN = g_ckmInfo.nextSerialNumber;
 370
 371     FUNCTION_CLEAR();
 372 }
 373
 374 /*CA Certificate Chain*/
 375 PKIError SetCAChain (const uint8_t CAChainLength, const ByteArray *CAChain)
 376 {
 377     FUNCTION_INIT();
 378     CHECK_NULL_BYTE_ARRAY_PTR(CAChain, ISSUER_CA_STORAGE_NULL_PASSED);
 379     CHECK_NULL(CAChainLength, ISSUER_CA_STORAGE_NULL_PASSED);
 380
 381     OICFree(g_ckmInfo.CACertificateChain);
 382     g_ckmInfo.CACertificateChain = NULL;
 383     g_ckmInfo.CACertificateChain = (ByteArray *)OICMalloc(sizeof(ByteArray) * CAChainLength);
 384     CHECK_NULL(g_ckmInfo.CACertificateChain, ISSUER_CA_STORAGE_MEMORY_ALLOC_FAILED);
 385
 386     for (int i = 0; i < CAChainLength; i++)
 387     {
 388         g_ckmInfo.CACertificateChain[i].data = (uint8_t *)OICMalloc(CAChain[i].len);
 389         CHECK_NULL(g_ckmInfo.CACertificateChain[i].data, ISSUER_CA_STORAGE_MEMORY_ALLOC_FAILED);
 390         memcpy(g_ckmInfo.CACertificateChain[i].data, CAChain[i].data, CAChain[i].len);
 391         g_ckmInfo.CACertificateChain[i].len = CAChain[i].len;
 392     }
 393     g_ckmInfo.CAChainLength = CAChainLength;
 394
 395     FUNCTION_CLEAR();
 396 }
 397
 398 PKIError GetCAChain (uint8_t* CAChainLength, ByteArray *CAChain)
 399 {
 400     FUNCTION_INIT();
 401     CHECK_COND(g_ckmInfo.CAChainLength, ISSUER_CA_STORAGE_CA_CHAIN_LENGTH_UNDEFINED);
 402     CHECK_NULL_BYTE_ARRAY_PTR(CAChain, ISSUER_CA_STORAGE_NULL_PASSED);
 403     CHECK_NULL(CAChainLength, PKI_NULL_PASSED);
 404
 405     for (int i = 0; i < g_ckmInfo.CAChainLength; i++)
 406     {
 407         CHECK_LESS_EQUAL(g_ckmInfo.CACertificateChain[i].len, CAChain[i].len,
 408                          ISSUER_CA_STORAGE_WRONG_BYTE_ARRAY_LEN);
 409         memcpy(CAChain[i].data, g_ckmInfo.CACertificateChain[i].data,
 410                g_ckmInfo.CACertificateChain[i].len);
 411         CAChain[i].len = g_ckmInfo.CACertificateChain[i].len;
 412     }
 413
 414     *CAChainLength = g_ckmInfo.CAChainLength;
 415
 416     FUNCTION_CLEAR();
 417 }
 418
 419 /*Certificate*/
 420 PKIError SetCACertificate (const ByteArray *CACertificate)
 421 {
 422     FUNCTION_INIT();
 423     CHECK_NULL_BYTE_ARRAY_PTR(CACertificate, ISSUER_CA_STORAGE_NULL_PASSED);
 424     CHECK_CALL(SetCAChain, 1, CACertificate);
 425
 426     FUNCTION_CLEAR();
 427 }
 428
 429 PKIError GetCACertificate (ByteArray *CACertificate)
 430 {
 431     FUNCTION_INIT();
 432     uint8_t i;
 433     CHECK_NULL_BYTE_ARRAY_PTR(CACertificate, ISSUER_CA_STORAGE_NULL_PASSED);
 434     CHECK_CALL(GetCAChain, &i, CACertificate);
 435
 436     FUNCTION_CLEAR();
 437 }
 438 //CRL-related functions
 439
 440 PKIError InitCRL(void)
 441 {
 442     FUNCTION_INIT();
 443     g_crlInfo = *(OicSecCrl_t *)GetCRLResource();
 444     CHECK_NULL(g_crlInfo.CrlData.data, ISSUER_CA_STORAGE_NULL_PASSED);
 445     CHECK_NULL(g_crlInfo.ThisUpdate.data, ISSUER_CA_STORAGE_NULL_PASSED);
 446
 447     FUNCTION_CLEAR();
 448 }
 449
 450 PKIError SaveCRL(void)
 451 {
 452     FUNCTION_INIT();
 453
 454     CHECK_EQUAL(UpdateCRLResource(&g_crlInfo),
 455                 OC_STACK_OK, ISSUER_CA_STORAGE_CRL_WRITE_ERROR);
 456     FUNCTION_CLEAR();
 457 }
 458
 459 /*CRL Serial Number*/
 460 PKIError SetCRLSerialNumber (const long *CRLSerialNumber)
 461 {
 462     FUNCTION_INIT();
 463     CHECK_NULL(CRLSerialNumber, ISSUER_CA_STORAGE_NULL_PASSED);
 464     CHECK_LESS_EQUAL(0, *CRLSerialNumber, ISSUER_CA_STORAGE_WRONG_CRL_SERIAL_NUMBER);
 465     g_ckmInfo.CRLSerialNumber = *CRLSerialNumber;
 466
 467     FUNCTION_CLEAR();
 468 }
 469
 470 PKIError GetCRLSerialNumber (long *CRLSerialNumber)
 471 {
 472     FUNCTION_INIT();
 473     CHECK_NULL(CRLSerialNumber, ISSUER_CA_STORAGE_NULL_PASSED);
 474     CHECK_NULL(g_ckmInfo.CRLSerialNumber, ISSUER_CA_STORAGE_CRL_SN_UNDEFINED);
 475     *CRLSerialNumber = g_ckmInfo.CRLSerialNumber;
 476
 477     FUNCTION_CLEAR();
 478 }
 479
 480 /*Revocation List*/
 481 PKIError SetCertificateRevocationList (const ByteArray *certificateRevocationList)
 482 {
 483     FUNCTION_INIT();
 484     CHECK_NULL_BYTE_ARRAY_PTR(certificateRevocationList, ISSUER_CA_STORAGE_NULL_PASSED);
 485
 486     OICFree(g_crlInfo.CrlData.data);
 487     g_crlInfo.CrlData.data = CRL_MEMORY_IS_NOT_ALLOCATED;
 488     g_crlInfo.CrlData.data = (uint8_t *)OICMalloc(certificateRevocationList->len + 1);
 489     CHECK_NULL(g_crlInfo.CrlData.data, ISSUER_CA_STORAGE_MEMORY_ALLOC_FAILED);
 490     memcpy(g_crlInfo.CrlData.data, certificateRevocationList->data, certificateRevocationList->len);
 491     g_crlInfo.CrlData.len = certificateRevocationList->len;
 492
 493     g_crlInfo.CrlId ++;
 494     CHECK_CALL(SaveCRL);
 495
 496     FUNCTION_CLEAR();
 497 }
 498
 499 PKIError GetCertificateRevocationList (ByteArray *certificateRevocationList)
 500 {
 501     FUNCTION_INIT();
 502     CHECK_COND(g_crlInfo.CrlData.data, ISSUER_CA_STORAGE_CRL_UNDEFINED);
 503     CHECK_NULL_BYTE_ARRAY_PTR(certificateRevocationList, ISSUER_CA_STORAGE_NULL_PASSED);
 504     OicSecCrl_t *tmpCRL;
 505     tmpCRL = (OicSecCrl_t *)GetCRLResource();
 506     g_crlInfo.CrlId = tmpCRL->CrlId;
 507     g_crlInfo.CrlData = tmpCRL->CrlData;
 508     g_crlInfo.ThisUpdate = tmpCRL->ThisUpdate;
 509
 510     CHECK_LESS_EQUAL(g_crlInfo.CrlData.len, certificateRevocationList->len,
 511                      ISSUER_WRONG_BYTE_ARRAY_LEN);
 512     memcpy(certificateRevocationList->data, g_crlInfo.CrlData.data, g_crlInfo.CrlData.len);
 513     certificateRevocationList->len = g_crlInfo.CrlData.len;
 514
 515     FUNCTION_CLEAR(
 516             OICFree(tmpCRL);
 517     );
 518 }
 519
 520 PKIError SetNumberOfRevoked (const long *numberOfRevoked)
 521 {
 522     FUNCTION_INIT();
 523     CHECK_NULL(numberOfRevoked, ISSUER_CA_STORAGE_NULL_PASSED);
 524     CHECK_LESS_EQUAL(0, *numberOfRevoked, ISSUER_CA_STORAGE_WRONG_CRL_SERIAL_NUMBER);
 525     g_ckmInfo.numberOfRevoked = *numberOfRevoked;
 526
 527     FUNCTION_CLEAR();
 528 }
 529 PKIError GetNumberOfRevoked (long *numberOfRevoked)
 530 {
 531     FUNCTION_INIT();
 532     CHECK_NULL(numberOfRevoked, ISSUER_CA_STORAGE_NULL_PASSED);
 533     CHECK_NULL(g_ckmInfo.numberOfRevoked, ISSUER_CA_STORAGE_CRL_SN_UNDEFINED);
 534     *numberOfRevoked = g_ckmInfo.numberOfRevoked;
 535
 536     FUNCTION_CLEAR();
 537 }