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.cpp
  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 <ckmc-type-converter.h>
  31 #include <protocols.h>
  32 #include <openssl/x509v3.h>
  33 #include <openssl/pkcs12.h>
  34 #include <openssl/evp.h>
  35 #include <openssl/pem.h>
  36
  37
  38 const char * const ckmc_label_name_separator = CKM::LABEL_NAME_SEPARATOR;
  39
  40
  41 int _ckmc_load_cert_from_x509(X509 *xCert, ckmc_cert_s **cert);
  42
  43 KEY_MANAGER_CAPI
  44 int ckmc_key_new(unsigned char *raw_key, size_t key_size, ckmc_key_type_e key_type, char *password, ckmc_key_s **ppkey)
  45 {
  46     ckmc_key_s *pkey;
  47
  48     if(raw_key == NULL || key_size <= 0 || ppkey == NULL) {
  49         return CKMC_ERROR_INVALID_PARAMETER;
  50     }
  51
  52     pkey = static_cast<ckmc_key_s*>(malloc(sizeof(ckmc_key_s)));
  53     if(pkey == NULL) {
  54         return CKMC_ERROR_OUT_OF_MEMORY;
  55     }
  56     pkey->raw_key = reinterpret_cast<unsigned char*>(malloc(key_size));
  57     if(pkey->raw_key == NULL) {
  58         free(pkey);
  59         return CKMC_ERROR_OUT_OF_MEMORY;
  60     }
  61     memcpy(pkey->raw_key, raw_key, key_size);
  62
  63     pkey->key_size = key_size;
  64     pkey->key_type = key_type;
  65
  66     if(password != NULL) {
  67         pkey->password = reinterpret_cast<char*>(malloc(strlen(password) +1));
  68         if(pkey->password == NULL) {
  69             free(pkey->raw_key);
  70             free(pkey);
  71             return CKMC_ERROR_OUT_OF_MEMORY;
  72         }
  73         memset(pkey->password, 0, strlen(password) +1);
  74         strncpy(pkey->password, password, strlen(password));
  75     }else {
  76         pkey->password = NULL;
  77     }
  78
  79     *ppkey = pkey;
  80
  81     return CKMC_ERROR_NONE;
  82 }
  83
  84 KEY_MANAGER_CAPI
  85 void ckmc_key_free(ckmc_key_s *key)
  86 {
  87     if(key == NULL)
  88         return;
  89
  90     if(key->password != NULL)
  91         free(key->password);
  92     if(key->raw_key != NULL) {
  93         memset(key->raw_key, 0, key->key_size);
  94         free(key->raw_key);
  95     }
  96
  97     free(key);
  98 }
  99
 100 KEY_MANAGER_CAPI
 101 int ckmc_buffer_new(unsigned char *data, size_t size,ckmc_raw_buffer_s **ppbuffer)
 102 {
 103     ckmc_raw_buffer_s *pbuff;
 104
 105     if(data == NULL || size <= 0 || ppbuffer == NULL) {
 106         return CKMC_ERROR_INVALID_PARAMETER;
 107     }
 108
 109     pbuff = static_cast<ckmc_raw_buffer_s*>(malloc(sizeof(ckmc_raw_buffer_s)));
 110     if(pbuff == NULL)
 111             return CKMC_ERROR_OUT_OF_MEMORY;
 112
 113     pbuff->data = reinterpret_cast<unsigned char*>(malloc(size));
 114     if(pbuff->data == NULL) {
 115         free(pbuff);
 116         return CKMC_ERROR_OUT_OF_MEMORY;
 117     }
 118     memcpy(pbuff->data, data, size);
 119
 120     pbuff->size = size;
 121     *ppbuffer = pbuff;
 122
 123     return CKMC_ERROR_NONE;
 124 }
 125
 126 KEY_MANAGER_CAPI
 127 void ckmc_buffer_free(ckmc_raw_buffer_s *buffer)
 128 {
 129     if(buffer == NULL)
 130         return;
 131
 132     if(buffer->data != NULL) {
 133         memset(buffer->data, 0, buffer->size);
 134         free(buffer->data);
 135     }
 136     free(buffer);
 137 }
 138
 139 KEY_MANAGER_CAPI
 140 int ckmc_cert_new(unsigned char *raw_cert, size_t cert_size, ckmc_data_format_e data_format, ckmc_cert_s **ppcert)
 141 {
 142     ckmc_cert_s *pcert;
 143
 144     if(raw_cert == NULL || cert_size <= 0 || ppcert == NULL) {
 145         return CKMC_ERROR_INVALID_PARAMETER;
 146     }
 147
 148     pcert = static_cast<ckmc_cert_s*>(malloc(sizeof(ckmc_cert_s)));
 149     if(pcert == NULL) {
 150         return CKMC_ERROR_OUT_OF_MEMORY;
 151     }
 152     pcert->raw_cert = reinterpret_cast<unsigned char*>(malloc(cert_size));
 153     if(pcert->raw_cert == NULL) {
 154         free(pcert);
 155         return CKMC_ERROR_OUT_OF_MEMORY;
 156     }
 157     memcpy(pcert->raw_cert, raw_cert, cert_size);
 158
 159     pcert->cert_size = cert_size;
 160     pcert->data_format = data_format;
 161
 162     *ppcert = pcert;
 163     return CKMC_ERROR_NONE;
 164 }
 165
 166 KEY_MANAGER_CAPI
 167 int ckmc_load_cert_from_file(const char *file_path, ckmc_cert_s **cert)
 168 {
 169     OpenSSL_add_all_algorithms();
 170
 171     FILE *fp = fopen(file_path, "r");
 172     if(fp == NULL)
 173         return CKMC_ERROR_FILE_ACCESS_DENIED;
 174     X509 *pcert = NULL;
 175     if(!(pcert = d2i_X509_fp(fp, NULL))) {
 176         fseek(fp, 0, SEEK_SET);
 177         pcert = PEM_read_X509(fp, NULL, NULL, NULL);
 178     }
 179     fclose(fp);
 180     if(pcert == NULL) {
 181         return CKMC_ERROR_INVALID_FORMAT;
 182     }
 183
 184     int ret = _ckmc_load_cert_from_x509(pcert, cert);
 185     if(ret != CKMC_ERROR_NONE) {
 186         X509_free(pcert);
 187     }
 188     return ret;
 189 }
 190
 191 KEY_MANAGER_CAPI
 192 void ckmc_cert_free(ckmc_cert_s *cert)
 193 {
 194     if(cert == NULL)
 195         return;
 196
 197     if(cert->raw_cert != NULL) {
 198         memset(cert->raw_cert, 0, cert->cert_size);
 199         free(cert->raw_cert);
 200     }
 201     free(cert);
 202 }
 203
 204 KEY_MANAGER_CAPI
 205 int ckmc_pkcs12_new(ckmc_key_s *private_key, ckmc_cert_s *cert,
 206         ckmc_cert_list_s *ca_cert_list, ckmc_pkcs12_s **pkcs12_bundle)
 207 {
 208     ckmc_pkcs12_s *pkcs12;
 209
 210     if(!pkcs12_bundle ||
 211        (private_key==NULL && cert==NULL && (ca_cert_list==NULL || ca_cert_list->cert==NULL))) {
 212         return CKMC_ERROR_INVALID_PARAMETER;
 213     }
 214
 215     pkcs12 = static_cast<ckmc_pkcs12_s*>(malloc(sizeof(ckmc_pkcs12_s)));
 216     if(pkcs12 == NULL) {
 217         return CKMC_ERROR_OUT_OF_MEMORY;
 218     }
 219     // ownership is transferred into pkcs12 - mentioned in the docs
 220     pkcs12->priv_key = private_key;
 221     pkcs12->cert = cert;
 222     pkcs12->ca_chain = ca_cert_list;
 223
 224     *pkcs12_bundle = pkcs12;
 225     return CKMC_ERROR_NONE;
 226 }
 227
 228 KEY_MANAGER_CAPI
 229 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)
 230 {
 231     class Pkcs12Converter {
 232     private:
 233         FILE* fp_in;
 234         PKCS12* p12;
 235         EVP_PKEY* pkey;
 236         X509* x509Cert;
 237         STACK_OF(X509)* ca;
 238
 239         int ret;
 240     public:
 241         ckmc_key_s *retPrivateKey;
 242         ckmc_cert_s *retCkmCert;
 243         ckmc_cert_list_s *retCaCertList;
 244
 245         Pkcs12Converter(){
 246             fp_in = NULL;
 247             p12 = NULL;
 248             pkey = NULL;
 249             x509Cert = NULL;
 250             ca = NULL;
 251             ret = CKMC_ERROR_NONE;
 252             retPrivateKey = NULL;
 253             retCkmCert = NULL;
 254             retCaCertList = NULL;
 255         };
 256         ~Pkcs12Converter(){
 257             if(fp_in != NULL)
 258                 fclose(fp_in);
 259             if(p12 != NULL)
 260                 PKCS12_free(p12);
 261             if(x509Cert != NULL)
 262                 X509_free(x509Cert);
 263             if(pkey != NULL)
 264                 EVP_PKEY_free(pkey);
 265             if(ca != NULL)
 266                 sk_X509_pop_free(ca, X509_free);
 267
 268             if(ret != CKMC_ERROR_NONE) {
 269                 if(retPrivateKey != NULL){
 270                     ckmc_key_free(retPrivateKey);
 271                     retPrivateKey = NULL;
 272                 }
 273                 if(retCkmCert != NULL) {
 274                     ckmc_cert_free(retCkmCert);
 275                     retCkmCert = NULL;
 276                 }
 277                 if(retCaCertList != NULL) {
 278                     ckmc_cert_list_all_free(retCaCertList);
 279                     retCaCertList = NULL;
 280                 }
 281             }
 282         };
 283
 284         int parsePkcs12(const char *filePath, const char *pass) {
 285             fp_in = NULL;
 286             if(!(fp_in = fopen(filePath, "rb"))) {
 287                 return CKMC_ERROR_FILE_ACCESS_DENIED;
 288             }
 289
 290             if(!(p12 = d2i_PKCS12_fp(fp_in, NULL))) {
 291                 return CKMC_ERROR_INVALID_FORMAT;
 292             }
 293
 294             /* parse PKCS#12 certificate */
 295             if((ret = PKCS12_parse(p12, pass, &pkey, &x509Cert, &ca)) != 1) {
 296                 return CKMC_ERROR_INVALID_FORMAT;
 297             }
 298             return CKMC_ERROR_NONE;
 299         }
 300
 301         int toCkmCert() {
 302             if( (ret =_ckmc_load_cert_from_x509(x509Cert,&retCkmCert)) != CKMC_ERROR_NONE) {
 303                 return ret;
 304             }
 305             return CKMC_ERROR_NONE;
 306         }
 307
 308         int toCkmKey() {
 309             BIO *bkey = BIO_new(BIO_s_mem());
 310
 311             i2d_PrivateKey_bio(bkey, pkey);
 312
 313             CKM::RawBuffer output(8196);
 314             int size = BIO_read(bkey, output.data(), output.size());
 315             BIO_free_all(bkey);
 316             if (size <= 0) {
 317                 return CKMC_ERROR_INVALID_FORMAT;
 318             }
 319             output.resize(size);
 320
 321             int type = EVP_PKEY_type(pkey->type);
 322             ckmc_key_type_e key_type = CKMC_KEY_NONE;
 323             switch(type) {
 324             case EVP_PKEY_RSA :
 325                 key_type = CKMC_KEY_RSA_PRIVATE;
 326                 break;
 327             case EVP_PKEY_DSA :
 328                 key_type = CKMC_KEY_DSA_PRIVATE;
 329                 break;
 330             case EVP_PKEY_EC :
 331                 key_type = CKMC_KEY_ECDSA_PRIVATE;
 332                 break;
 333             }
 334             if(key_type == CKMC_KEY_NONE) {
 335                 return CKMC_ERROR_INVALID_FORMAT;
 336             }
 337
 338             char *nullPassword = NULL;
 339
 340             return ckmc_key_new(output.data(), size, key_type, nullPassword, &retPrivateKey);
 341         }
 342
 343         int toCaCkmCertList() {
 344             int tmpRet;
 345             X509* popedCert = NULL;
 346             ckmc_cert_s *popedCkmCert = NULL;
 347             ckmc_cert_list_s *tmpCertList = NULL;
 348             while((popedCert = sk_X509_pop(ca)) != NULL) {
 349                 if( (tmpRet =_ckmc_load_cert_from_x509(popedCert, &popedCkmCert)) != CKMC_ERROR_NONE) {
 350                     return CKMC_ERROR_OUT_OF_MEMORY;
 351                 }
 352                 if(tmpCertList == NULL) { // first
 353                     tmpRet = ckmc_cert_list_new(popedCkmCert, &tmpCertList);
 354                     retCaCertList = tmpCertList;
 355                 }else {
 356                     tmpRet = ckmc_cert_list_add(tmpCertList, popedCkmCert, &tmpCertList);
 357                 }
 358                 if(tmpRet != CKMC_ERROR_NONE) {
 359                     ckmc_cert_list_all_free(retCaCertList);
 360                     retCaCertList = NULL;
 361                     return tmpRet;
 362                 }
 363             }
 364             return CKMC_ERROR_NONE;
 365         }
 366
 367     };
 368
 369     OpenSSL_add_all_algorithms();
 370
 371     int ret = CKMC_ERROR_NONE;
 372
 373     Pkcs12Converter converter;
 374     if((ret = converter.parsePkcs12(file_path, passphrase)) != CKMC_ERROR_NONE) {
 375         return ret;
 376     }
 377     if((ret = converter.toCkmCert()) != CKMC_ERROR_NONE) {
 378         return ret;
 379     }
 380     if((ret = converter.toCkmKey()) != CKMC_ERROR_NONE) {
 381         return ret;
 382     }
 383     if((ret = converter.toCaCkmCertList()) != CKMC_ERROR_NONE) {
 384         return ret;
 385     }
 386
 387     *private_key = converter.retPrivateKey;
 388     *ckmcert = converter.retCkmCert;
 389     *ca_cert_list = converter.retCaCertList;
 390
 391     return CKMC_ERROR_NONE;
 392 }
 393
 394 KEY_MANAGER_CAPI
 395 int ckmc_pkcs12_load(const char *file_path, const char *passphrase, ckmc_pkcs12_s **pkcs12_bundle)
 396 {
 397     int ec;
 398     ckmc_key_s *private_key = 0;
 399     ckmc_cert_s *cert = 0;
 400     ckmc_cert_list_s *ca_cert_list = 0;
 401
 402     if(!file_path || !pkcs12_bundle)
 403         return CKMC_ERROR_INVALID_PARAMETER;
 404
 405     ec = ckmc_load_from_pkcs12_file(file_path, passphrase, &private_key, &cert, &ca_cert_list);
 406     if(ec != CKMC_ERROR_NONE)
 407         return ec;
 408
 409     ec = ckmc_pkcs12_new(private_key, cert, ca_cert_list, pkcs12_bundle);
 410     if(ec != CKMC_ERROR_NONE)
 411     {
 412         ckmc_key_free(private_key);
 413         ckmc_cert_free(cert);
 414         ckmc_cert_list_free(ca_cert_list);
 415         return ec;
 416     }
 417
 418     return CKMC_ERROR_NONE;
 419 }
 420
 421 KEY_MANAGER_CAPI
 422 void ckmc_pkcs12_free(ckmc_pkcs12_s *pkcs12)
 423 {
 424     if(pkcs12 == NULL)
 425         return;
 426
 427     ckmc_key_free(pkcs12->priv_key);
 428     ckmc_cert_free(pkcs12->cert);
 429     ckmc_cert_list_all_free(pkcs12->ca_chain);
 430     free(pkcs12);
 431 }
 432
 433 KEY_MANAGER_CAPI
 434 int ckmc_alias_list_new(char *alias, ckmc_alias_list_s **ppalias_list)
 435 {
 436     ckmc_alias_list_s *previous = NULL;
 437     return ckmc_alias_list_add(previous, alias, ppalias_list);
 438 }
 439
 440 KEY_MANAGER_CAPI
 441 int ckmc_alias_list_add(ckmc_alias_list_s *previous, char *alias, ckmc_alias_list_s **pplast)
 442 {
 443     ckmc_alias_list_s *plist;
 444
 445     if(alias == NULL || pplast == NULL) {
 446         return CKMC_ERROR_INVALID_PARAMETER;
 447     }
 448
 449     plist = static_cast<ckmc_alias_list_s*>(malloc(sizeof(ckmc_alias_list_s)));
 450     if(plist == NULL) {
 451         return CKMC_ERROR_OUT_OF_MEMORY;
 452     }
 453
 454     plist->alias = alias;
 455     plist->next = NULL;
 456
 457     if(previous != NULL) {
 458         previous->next = plist;
 459     }
 460     *pplast = plist;
 461
 462     return CKMC_ERROR_NONE;
 463 }
 464
 465 KEY_MANAGER_CAPI
 466 void ckmc_alias_list_free(ckmc_alias_list_s *first)
 467 {
 468     ckmc_alias_list_s *next = first;
 469     while (next) {
 470         ckmc_alias_list_s *current = next;
 471         next = current->next;
 472         free(current);
 473     }
 474 }
 475
 476 KEY_MANAGER_CAPI
 477 void ckmc_alias_list_all_free(ckmc_alias_list_s *first)
 478 {
 479     ckmc_alias_list_s *next = first;
 480     while (next) {
 481         ckmc_alias_list_s *current = next;
 482         next = current->next;
 483         free(current->alias);
 484         free(current);
 485     }
 486 }
 487
 488 KEY_MANAGER_CAPI
 489 int ckmc_cert_list_new(ckmc_cert_s *cert, ckmc_cert_list_s **ppalias_list)
 490 {
 491     ckmc_cert_list_s *previous = NULL;
 492     return ckmc_cert_list_add(previous, cert, ppalias_list);
 493 }
 494
 495 KEY_MANAGER_CAPI
 496 int ckmc_cert_list_add(ckmc_cert_list_s *previous, ckmc_cert_s *cert, ckmc_cert_list_s **pplast)
 497 {
 498     ckmc_cert_list_s *plist;
 499
 500     if(cert == NULL || pplast == NULL) {
 501         return CKMC_ERROR_INVALID_PARAMETER;
 502     }
 503
 504     plist = static_cast<ckmc_cert_list_s*>(malloc(sizeof(ckmc_cert_list_s)));
 505     if(plist == NULL) {
 506         return CKMC_ERROR_OUT_OF_MEMORY;
 507     }
 508     plist->cert = cert;
 509     plist->next = NULL;
 510
 511     if(previous != NULL) {
 512         previous->next = plist;
 513     }
 514
 515     *pplast = plist;
 516
 517     return CKMC_ERROR_NONE;
 518 }
 519
 520 KEY_MANAGER_CAPI
 521 void ckmc_cert_list_free(ckmc_cert_list_s *first)
 522 {
 523     ckmc_cert_list_s *next = first;
 524     while (next) {
 525         ckmc_cert_list_s *current = next;
 526         next = current->next;
 527         free(current);
 528     }
 529 }
 530
 531 KEY_MANAGER_CAPI
 532 void ckmc_cert_list_all_free(ckmc_cert_list_s *first)
 533 {
 534     ckmc_cert_list_s *next = first;
 535     while (next) {
 536         ckmc_cert_list_s *current = next;
 537         next = current->next;
 538         ckmc_cert_free(current->cert);
 539         free(current);
 540     }
 541 }
 542
 543 int _ckmc_load_cert_from_x509(X509 *xCert, ckmc_cert_s **cert)
 544 {
 545     if(xCert == NULL) {
 546         return CKMC_ERROR_INVALID_FORMAT;
 547     }
 548
 549     BIO *bcert = BIO_new(BIO_s_mem());
 550
 551     i2d_X509_bio(bcert, xCert);
 552
 553     CKM::RawBuffer output(8196);
 554     int size = BIO_read(bcert, output.data(), output.size());
 555     BIO_free_all(bcert);
 556     if (size <= 0) {
 557         return CKMC_ERROR_INVALID_FORMAT;
 558     }
 559     output.resize(size);
 560
 561     return ckmc_cert_new(output.data(), output.size(), CKMC_FORM_DER, cert);
 562 }
 563