src/manager/client-capi/ckmc-type.cpp

   1 /*
   2  *  Copyright (c) 2000 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Licensed under the Apache License, Version 2.0 (the "License");
   5  *  you may not use this file except in compliance with the License.
   6  *  You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License
  15  *
  16  *
  17  * @file        ckmc-type.h
  18  * @author      Yuseok Jeon(yuseok.jeon@samsung.com)
  19  * @version     1.0
  20  * @brief       new and free methods for the struct of CAPI
  21  */
  22
  23
  24 #include <string.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <ckm/ckm-type.h>
  28 #include <ckmc/ckmc-type.h>
  29 #include <ckmc/ckmc-error.h>
  30 #include <openssl/x509v3.h>
  31 #include <openssl/pkcs12.h>
  32 #include <openssl/evp.h>
  33 #include <openssl/pem.h>
  34
  35 int _ckmc_load_cert_from_x509(X509 *xCert, ckmc_cert_s **cert);
  36
  37 KEY_MANAGER_CAPI
  38 int ckmc_key_new(unsigned char *raw_key, size_t key_size, ckmc_key_type_e key_type, char *password, ckmc_key_s **ppkey)
  39 {
  40         ckmc_key_s *pkey;
  41
  42         if(raw_key == NULL || key_size <= 0 || ppkey == NULL) {
  43                 return CKMC_ERROR_INPUT_PARAM;
  44         }
  45
  46         pkey = new ckmc_key_s;
  47         if(pkey == NULL) {
  48                 return CKMC_ERROR_OUT_OF_MEMORY;
  49         }
  50         pkey->raw_key = reinterpret_cast<unsigned char*>(malloc(key_size));
  51         if(pkey->raw_key == NULL) {
  52                 free(pkey);
  53                 return CKMC_ERROR_OUT_OF_MEMORY;
  54         }
  55         memcpy(pkey->raw_key, raw_key, key_size);
  56
  57         pkey->key_size = key_size;
  58         pkey->key_type = key_type;
  59
  60         if(password != NULL) {
  61                 pkey->password = reinterpret_cast<char*>(malloc(strlen(password) +1));
  62                 if(pkey->password == NULL) {
  63                         free(pkey);
  64                         free(pkey->raw_key);
  65                         return CKMC_ERROR_OUT_OF_MEMORY;
  66                 }
  67                 memset(pkey->password, 0, strlen(password) +1);
  68                 strncpy(pkey->password, password, strlen(password));
  69         }else {
  70                 pkey->password = NULL;
  71         }
  72
  73         *ppkey = pkey;
  74
  75         return CKMC_SUCCESS;
  76 }
  77
  78 KEY_MANAGER_CAPI
  79 void ckmc_key_free(ckmc_key_s *key)
  80 {
  81         if(key == NULL)
  82                 return;
  83
  84         if(key->password != NULL)
  85                 free(key->password);
  86         if(key->raw_key != NULL) {
  87                 memset(key->raw_key, 0, key->key_size);
  88                 free(key->raw_key);
  89         }
  90
  91         free(key);
  92 }
  93
  94 KEY_MANAGER_CAPI
  95 int ckmc_buffer_new(unsigned char *data, size_t size,ckmc_raw_buffer_s **ppbuffer)
  96 {
  97         ckmc_raw_buffer_s *pbuff;
  98
  99         if(data == NULL || size <= 0 || ppbuffer == NULL) {
 100                 return CKMC_ERROR_INPUT_PARAM;
 101         }
 102
 103         pbuff = new ckmc_raw_buffer_s;
 104         if(pbuff == NULL)
 105                         return CKMC_ERROR_OUT_OF_MEMORY;
 106
 107         pbuff->data = reinterpret_cast<unsigned char*>(malloc(size));
 108         if(pbuff->data == NULL) {
 109                 free(pbuff);
 110                 return CKMC_ERROR_OUT_OF_MEMORY;
 111         }
 112         memcpy(pbuff->data, data, size);
 113
 114         pbuff->size = size;
 115         *ppbuffer = pbuff;
 116
 117         return CKMC_SUCCESS;
 118 }
 119
 120 KEY_MANAGER_CAPI
 121 void ckmc_buffer_free(ckmc_raw_buffer_s *buffer)
 122 {
 123         if(buffer == NULL)
 124                 return;
 125
 126         if(buffer->data != NULL) {
 127                 memset(buffer->data, 0, buffer->size);
 128                 free(buffer->data);
 129         }
 130         free(buffer);
 131 }
 132
 133 KEY_MANAGER_CAPI
 134 int ckmc_cert_new(unsigned char *raw_cert, size_t cert_size, ckmc_data_format_e data_format, ckmc_cert_s **ppcert)
 135 {
 136         ckmc_cert_s *pcert;
 137
 138         if(raw_cert == NULL || cert_size <= 0 || ppcert == NULL) {
 139                 return CKMC_ERROR_INPUT_PARAM;
 140         }
 141
 142         pcert = new ckmc_cert_s;
 143         if(pcert == NULL) {
 144                 return CKMC_ERROR_OUT_OF_MEMORY;
 145         }
 146         pcert->raw_cert = reinterpret_cast<unsigned char*>(malloc(cert_size));
 147         if(pcert->raw_cert == NULL) {
 148                 free(pcert);
 149                 return CKMC_ERROR_OUT_OF_MEMORY;
 150         }
 151         memcpy(pcert->raw_cert, raw_cert, cert_size);
 152
 153         pcert->cert_size = cert_size;
 154         pcert->data_format = data_format;
 155
 156         *ppcert = pcert;
 157         return CKMC_SUCCESS;
 158 }
 159
 160 KEY_MANAGER_CAPI
 161 int ckmc_load_cert_from_file(const char *file_path, ckmc_cert_s **cert)
 162 {
 163         OpenSSL_add_all_algorithms();
 164
 165         FILE *fp = fopen(file_path, "r");
 166         if(fp == NULL)
 167                 return CKMC_ERROR_FILE_ACCESS_DENIED;
 168         X509 *pcert = NULL;
 169         if(!(pcert = d2i_X509_fp(fp, NULL))) {
 170                 fseek(fp, 0, SEEK_SET);
 171                 pcert = PEM_read_X509(fp, NULL, NULL, NULL);
 172         }
 173         fclose(fp);
 174         if(pcert == NULL) {
 175                 return CKMC_ERROR_INVALID_FORMAT;
 176         }
 177
 178         int ret = _ckmc_load_cert_from_x509(pcert, cert);
 179         if(ret != CKMC_SUCCESS) {
 180                 X509_free(pcert);
 181         }
 182         return ret;
 183 }
 184
 185 KEY_MANAGER_CAPI
 186 int ckmc_load_from_pkcs12_file(const char *file_path, const char *passphrase, ckmc_key_s **private_key, ckmc_cert_s **ckmcert, ckmc_cert_list_s **ca_cert_list)
 187 {
 188         class Pkcs12Converter {
 189         private:
 190                 FILE* fp_in;
 191                 PKCS12* p12;
 192                 EVP_PKEY* pkey;
 193                 X509* x509Cert;
 194                 STACK_OF(X509)* ca;
 195
 196                 int ret;
 197         public:
 198                 ckmc_key_s *retPrivateKey;
 199                 ckmc_cert_s *retCkmCert;
 200                 ckmc_cert_list_s *retCaCertList;
 201
 202                 Pkcs12Converter(){
 203                         fp_in = NULL;
 204                         p12 = NULL;
 205                         pkey = NULL;
 206                         x509Cert = NULL;
 207                         ca = NULL;
 208                         ret = CKMC_SUCCESS;
 209                         retPrivateKey = NULL;
 210                         retCkmCert = NULL;
 211                         retCaCertList = NULL;
 212                 };
 213                 ~Pkcs12Converter(){
 214                         if(fp_in != NULL)
 215                                 fclose(fp_in);
 216                         if(p12 != NULL)
 217                                 PKCS12_free(p12);
 218                         if(x509Cert != NULL)
 219                                 X509_free(x509Cert);
 220                         if(pkey != NULL)
 221                                 EVP_PKEY_free(pkey);
 222                         if(ca != NULL)
 223                                 sk_X509_pop_free(ca, X509_free);
 224                         EVP_cleanup();
 225
 226                         if(ret != CKMC_SUCCESS) {
 227                                 if(retPrivateKey != NULL){
 228                                         ckmc_key_free(retPrivateKey);
 229                                         retPrivateKey = NULL;
 230                                 }
 231                                 if(retCkmCert != NULL) {
 232                                         ckmc_cert_free(retCkmCert);
 233                                         retCkmCert = NULL;
 234                                 }
 235                                 if(retCaCertList != NULL) {
 236                                         ckmc_cert_list_all_free(retCaCertList);
 237                                         retCaCertList = NULL;
 238                                 }
 239                         }
 240                 };
 241
 242                 int parsePkcs12(const char *filePath, const char *pass) {
 243                         fp_in = NULL;
 244                         if(!(fp_in = fopen(filePath, "rb"))) {
 245                                 return CKMC_ERROR_FILE_ACCESS_DENIED;
 246                         }
 247
 248                         if(!(p12 = d2i_PKCS12_fp(fp_in, NULL))) {
 249                                 return CKMC_ERROR_INVALID_FORMAT;
 250                         }
 251
 252                         /* parse PKCS#12 certificate */
 253                         if((ret = PKCS12_parse(p12, pass, &pkey, &x509Cert, &ca)) != 1) {
 254                                 return CKMC_ERROR_INVALID_FORMAT;
 255                         }
 256                         return CKMC_SUCCESS;
 257                 }
 258
 259                 int toCkmCert() {
 260                         if( (ret =_ckmc_load_cert_from_x509(x509Cert,&retCkmCert)) != CKMC_SUCCESS) {
 261                                 return ret;
 262                         }
 263                         return CKMC_SUCCESS;
 264                 }
 265
 266                 int toCkmKey() {
 267                         BIO *bkey = BIO_new(BIO_s_mem());
 268
 269                         i2d_PrivateKey_bio(bkey, pkey);
 270
 271                     CKM::RawBuffer output(8196);
 272                     int size = BIO_read(bkey, output.data(), output.size());
 273                         BIO_free_all(bkey);
 274                     if (size <= 0) {
 275                         return CKMC_ERROR_INVALID_FORMAT;
 276                     }
 277                     output.resize(size);
 278
 279                         int type = EVP_PKEY_type(pkey->type);
 280                         ckmc_key_type_e key_type = CKMC_KEY_NONE;
 281                         switch(type) {
 282                         case EVP_PKEY_RSA :
 283                                 key_type = CKMC_KEY_RSA_PRIVATE;
 284                                 break;
 285                         case EVP_PKEY_EC :
 286                                 key_type = CKMC_KEY_ECDSA_PRIVATE;
 287                                 break;
 288                         }
 289                         if(key_type == CKMC_KEY_NONE) {
 290                                 return CKMC_ERROR_INVALID_FORMAT;
 291                         }
 292
 293                         char *nullPassword = NULL;
 294
 295                         return ckmc_key_new(output.data(), size, key_type, nullPassword, &retPrivateKey);
 296                 }
 297
 298                 int toCaCkmCertList() {
 299                         int tmpRet;
 300                         X509* popedCert = NULL;
 301                         ckmc_cert_s *popedCkmCert = NULL;
 302                         ckmc_cert_list_s *tmpCertList = NULL;
 303                         while((popedCert = sk_X509_pop(ca)) != NULL) {
 304                                 if( (tmpRet =_ckmc_load_cert_from_x509(popedCert, &popedCkmCert)) != CKMC_SUCCESS) {
 305                                         return CKMC_ERROR_OUT_OF_MEMORY;
 306                                 }
 307                                 if(tmpCertList == NULL) { // first
 308                                         tmpRet = ckmc_cert_list_new(popedCkmCert, &tmpCertList);
 309                                         retCaCertList = tmpCertList;
 310                                 }else {
 311                                         tmpRet = ckmc_cert_list_add(tmpCertList, popedCkmCert, &tmpCertList);
 312                                 }
 313                                 if(tmpRet != CKMC_SUCCESS) {
 314                                         ckmc_cert_list_all_free(retCaCertList);
 315                                         retCaCertList = NULL;
 316                                         return tmpRet;
 317                                 }
 318                         }
 319                         return CKMC_SUCCESS;
 320                 }
 321
 322         };
 323
 324         int ret = CKMC_SUCCESS;
 325
 326         Pkcs12Converter converter;
 327         if((ret = converter.parsePkcs12(file_path, passphrase)) != CKMC_SUCCESS) {
 328                 return ret;
 329         }
 330         if((ret = converter.toCkmCert()) != CKMC_SUCCESS) {
 331                 return ret;
 332         }
 333         if((ret = converter.toCkmKey()) != CKMC_SUCCESS) {
 334                 return ret;
 335         }
 336         if((ret = converter.toCaCkmCertList()) != CKMC_SUCCESS) {
 337                 return ret;
 338         }
 339
 340         *private_key = converter.retPrivateKey;
 341         *ckmcert = converter.retCkmCert;
 342         *ca_cert_list = converter.retCaCertList;
 343
 344         return CKMC_SUCCESS;
 345 }
 346
 347 KEY_MANAGER_CAPI
 348 void ckmc_cert_free(ckmc_cert_s *cert)
 349 {
 350         if(cert == NULL)
 351                 return;
 352
 353         if(cert->raw_cert != NULL) {
 354                 memset(cert->raw_cert, 0, cert->cert_size);
 355                 free(cert->raw_cert);
 356         }
 357         free(cert);
 358 }
 359
 360 KEY_MANAGER_CAPI
 361 int ckmc_alias_list_new(char *alias, ckmc_alias_list_s **ppalias_list)
 362 {
 363         ckmc_alias_list_s *previous = NULL;
 364         return ckmc_alias_list_add(previous, alias, ppalias_list);
 365 }
 366
 367 KEY_MANAGER_CAPI
 368 int ckmc_alias_list_add(ckmc_alias_list_s *previous, char *alias, ckmc_alias_list_s **pplast)
 369 {
 370         ckmc_alias_list_s *plist;
 371
 372         if(alias == NULL || pplast == NULL) {
 373                 return CKMC_ERROR_INPUT_PARAM;
 374         }
 375
 376         plist = new ckmc_alias_list_s;
 377         if(plist == NULL) {
 378                 return CKMC_ERROR_OUT_OF_MEMORY;
 379         }
 380
 381         plist->alias = alias;
 382         plist->next = NULL;
 383
 384         if(previous != NULL) {
 385                 previous->next = plist;
 386         }
 387         *pplast = plist;
 388
 389         return CKMC_SUCCESS;
 390 }
 391
 392 KEY_MANAGER_CAPI
 393 void ckmc_alias_list_free(ckmc_alias_list_s *first)
 394 {
 395         if(first == NULL)
 396                 return;
 397
 398         ckmc_alias_list_s *current = NULL;
 399         ckmc_alias_list_s *next = first;
 400         do {
 401                 current = next;
 402                 next = current->next;
 403                 free(current);
 404         }while(next != NULL);
 405 }
 406
 407 KEY_MANAGER_CAPI
 408 void ckmc_alias_list_all_free(ckmc_alias_list_s *first)
 409 {
 410         if(first == NULL)
 411                 return;
 412         ckmc_alias_list_s *current = NULL;
 413         ckmc_alias_list_s *next = first;
 414         do {
 415                 current = next;
 416                 next = current->next;
 417                 if((current->alias)!=NULL) {
 418                         free(current->alias);
 419                 }
 420                 free(current);
 421         }while(next != NULL);
 422 }
 423
 424 KEY_MANAGER_CAPI
 425 int ckmc_cert_list_new(ckmc_cert_s *cert, ckmc_cert_list_s **ppalias_list)
 426 {
 427         ckmc_cert_list_s *previous = NULL;
 428         return ckmc_cert_list_add(previous, cert, ppalias_list);
 429 }
 430
 431 KEY_MANAGER_CAPI
 432 int ckmc_cert_list_add(ckmc_cert_list_s *previous, ckmc_cert_s *cert, ckmc_cert_list_s **pplast)
 433 {
 434         ckmc_cert_list_s *plist;
 435
 436         if(cert == NULL || pplast == NULL) {
 437                 return CKMC_ERROR_INPUT_PARAM;
 438         }
 439
 440         plist = new ckmc_cert_list_s;
 441         if(plist == NULL) {
 442                 return CKMC_ERROR_OUT_OF_MEMORY;
 443         }
 444         plist->cert = cert;
 445         plist->next = NULL;
 446
 447         if(previous != NULL) {
 448                 previous->next = plist;
 449         }
 450
 451         *pplast = plist;
 452
 453         return CKMC_SUCCESS;
 454 }
 455
 456 KEY_MANAGER_CAPI
 457 void ckmc_cert_list_free(ckmc_cert_list_s *first)
 458 {
 459         if(first == NULL)
 460                 return;
 461
 462         ckmc_cert_list_s *current = NULL;
 463         ckmc_cert_list_s *next = first;
 464         do {
 465                 current = next;
 466                 next = current->next;
 467                 free(current);
 468         }while(next != NULL);
 469 }
 470
 471 KEY_MANAGER_CAPI
 472 void ckmc_cert_list_all_free(ckmc_cert_list_s *first)
 473 {
 474         if(first == NULL)
 475                 return;
 476
 477         ckmc_cert_list_s *current = NULL;
 478         ckmc_cert_list_s *next = first;
 479         do {
 480                 current = next;
 481                 next = current->next;
 482                 if((current->cert)!=NULL) {
 483                         ckmc_cert_free(current->cert);
 484                 }
 485                 free(current);
 486         }while(next != NULL);
 487 }
 488
 489 int _ckmc_load_cert_from_x509(X509 *xCert, ckmc_cert_s **cert)
 490 {
 491         if(xCert == NULL) {
 492                 return CKMC_ERROR_INVALID_FORMAT;
 493         }
 494
 495         BIO *bcert = BIO_new(BIO_s_mem());
 496
 497         i2d_X509_bio(bcert, xCert);
 498
 499     CKM::RawBuffer output(8196);
 500     int size = BIO_read(bcert, output.data(), output.size());
 501         BIO_free_all(bcert);
 502     if (size <= 0) {
 503         return CKMC_ERROR_INVALID_FORMAT;
 504     }
 505     output.resize(size);
 506
 507         return ckmc_cert_new(output.data(), output.size(), CKMC_FORM_DER, cert);
 508 }