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 **cert);
  36
  37
  38 KEY_MANAGER_CAPI
  39 ckmc_key *ckmc_key_new(unsigned char *raw_key, size_t key_size, ckmc_key_type key_type, char *password)
  40 {
  41         ckmc_key *pkey = new ckmc_key;
  42         if(pkey == NULL)
  43                 return NULL;
  44
  45         pkey->raw_key = reinterpret_cast<unsigned char*>(malloc(key_size));
  46         if(pkey->raw_key == NULL) {
  47                 free(pkey);
  48                 return NULL;
  49         }
  50         memcpy(pkey->raw_key, raw_key, key_size);
  51
  52         pkey->key_size = key_size;
  53         pkey->key_type = key_type;
  54
  55         if(password != NULL) {
  56                 pkey->password = reinterpret_cast<char*>(malloc(strlen(password) +1));
  57                 if(pkey->password == NULL) {
  58                         free(pkey);
  59                         free(pkey->raw_key);
  60                         return NULL;
  61                 }
  62                 memset(pkey->password, 0, strlen(password) +1);
  63                 strncpy(pkey->password, password, strlen(password));
  64         }else {
  65                 pkey->password = NULL;
  66         }
  67
  68         return pkey;
  69 }
  70
  71 KEY_MANAGER_CAPI
  72 void ckmc_key_free(ckmc_key *key)
  73 {
  74         if(key == NULL)
  75                 return;
  76
  77         if(key->password != NULL)
  78                 free(key->password);
  79         if(key->raw_key != NULL) {
  80                 memset(key->raw_key, 0, key->key_size);
  81                 free(key->raw_key);
  82         }
  83
  84         free(key);
  85 }
  86
  87 KEY_MANAGER_CAPI
  88 ckmc_raw_buffer * ckmc_buffer_new(unsigned char *data, size_t size)
  89 {
  90         ckmc_raw_buffer *pbuff = new ckmc_raw_buffer;
  91         if(pbuff == NULL)
  92                         return NULL;
  93
  94         pbuff->data = reinterpret_cast<unsigned char*>(malloc(size));
  95         if(pbuff->data == NULL) {
  96                 free(pbuff);
  97                 return NULL;
  98         }
  99         memcpy(pbuff->data, data, size);
 100
 101         pbuff->size = size;
 102
 103         return pbuff;
 104 }
 105
 106 KEY_MANAGER_CAPI
 107 void ckmc_buffer_free(ckmc_raw_buffer *buffer)
 108 {
 109         if(buffer == NULL)
 110                 return;
 111
 112         if(buffer->data != NULL) {
 113                 memset(buffer->data, 0, buffer->size);
 114                 free(buffer->data);
 115         }
 116         free(buffer);
 117 }
 118
 119 KEY_MANAGER_CAPI
 120 ckmc_cert *ckmc_cert_new(unsigned char *raw_cert, size_t cert_size, ckmc_data_format data_format)
 121 {
 122         ckmc_cert *pcert = new ckmc_cert;
 123         if(pcert == NULL)
 124                 return NULL;
 125
 126         pcert->raw_cert = reinterpret_cast<unsigned char*>(malloc(cert_size));
 127         if(pcert->raw_cert == NULL) {
 128                 free(pcert);
 129                 return NULL;
 130         }
 131         memcpy(pcert->raw_cert, raw_cert, cert_size);
 132
 133         pcert->cert_size = cert_size;
 134         pcert->data_format = data_format;
 135
 136         return pcert;
 137 }
 138
 139 KEY_MANAGER_CAPI
 140 int ckmc_load_cert_from_file(const char *file_path, ckmc_cert **cert)
 141 {
 142         OpenSSL_add_all_algorithms();
 143
 144         FILE *fp = fopen(file_path, "r");
 145         if(fp == NULL)
 146                 return CKMC_API_ERROR_FILE_ACCESS_DENIED;
 147         X509 *pcert = NULL;
 148         if(!(pcert = d2i_X509_fp(fp, NULL))) {
 149                 fseek(fp, 0, SEEK_SET);
 150                 pcert = PEM_read_X509(fp, NULL, NULL, NULL);
 151         }
 152         fclose(fp);
 153         if(pcert == NULL) {
 154                 return CKMC_API_ERROR_INVALID_FORMAT;
 155         }
 156
 157         int ret = _ckmc_load_cert_from_x509(pcert, cert);
 158         if(ret != CKMC_API_SUCCESS) {
 159                 X509_free(pcert);
 160         }
 161         return ret;
 162 }
 163
 164 KEY_MANAGER_CAPI
 165 int ckmc_load_from_pkcs12_file(const char *file_path, const char *passphrase, ckmc_key **private_key, ckmc_cert **ckmcert, ckmc_cert_list **ca_cert_list)
 166 {
 167         class Pkcs12Converter {
 168         private:
 169                 FILE* fp_in;
 170                 PKCS12* p12;
 171                 EVP_PKEY* pkey;
 172                 X509* x509Cert;
 173                 STACK_OF(X509)* ca;
 174
 175                 int ret;
 176         public:
 177                 ckmc_key *retPrivateKey;
 178                 ckmc_cert *retCkmCert;
 179                 ckmc_cert_list *retCaCertList;
 180
 181                 Pkcs12Converter(){
 182                         fp_in = NULL;
 183                         p12 = NULL;
 184                         pkey = NULL;
 185                         x509Cert = NULL;
 186                         ca = NULL;
 187                         ret = CKMC_API_SUCCESS;
 188                         retPrivateKey = NULL;
 189                         retCkmCert = NULL;
 190                         retCaCertList = NULL;
 191                 };
 192                 ~Pkcs12Converter(){
 193                         if(fp_in != NULL)
 194                                 fclose(fp_in);
 195                         if(p12 != NULL)
 196                                 PKCS12_free(p12);
 197                         if(x509Cert != NULL)
 198                                 X509_free(x509Cert);
 199                         if(pkey != NULL)
 200                                 EVP_PKEY_free(pkey);
 201                         if(ca != NULL)
 202                                 sk_X509_pop_free(ca, X509_free);
 203                         EVP_cleanup();
 204
 205                         if(ret != CKMC_API_SUCCESS) {
 206                                 if(retPrivateKey != NULL)
 207                                         ckmc_key_free(retPrivateKey);
 208                                 if(retCkmCert != NULL)
 209                                         ckmc_cert_free(retCkmCert);
 210                                 if(retCaCertList != NULL)
 211                                         ckmc_cert_list_all_free(retCaCertList);
 212                         }
 213                 };
 214
 215                 int parsePkcs12(const char *filePath, const char *pass) {
 216                         fp_in = NULL;
 217                         if(!(fp_in = fopen(filePath, "rb"))) {
 218                                 return CKMC_API_ERROR_FILE_ACCESS_DENIED;
 219                         }
 220
 221                         if(!(p12 = d2i_PKCS12_fp(fp_in, NULL))) {
 222                                 return CKMC_API_ERROR_INVALID_FORMAT;
 223                         }
 224
 225                         /* parse PKCS#12 certificate */
 226                         if((ret = PKCS12_parse(p12, pass, &pkey, &x509Cert, &ca)) != 1) {
 227                                 return CKMC_API_ERROR_INVALID_FORMAT;
 228                         }
 229                         return CKMC_API_SUCCESS;
 230                 }
 231
 232                 int toCkmCert() {
 233                         if( (ret =_ckmc_load_cert_from_x509(x509Cert,&retCkmCert)) != CKMC_API_SUCCESS) {
 234                                 return ret;
 235                         }
 236                         return CKMC_API_SUCCESS;
 237                 }
 238
 239                 int toCkmKey() {
 240                         BIO *bkey = BIO_new(BIO_s_mem());
 241
 242                         i2d_PrivateKey_bio(bkey, pkey);
 243
 244                     CKM::RawBuffer output(8196);
 245                     int size = BIO_read(bkey, output.data(), output.size());
 246                         BIO_free_all(bkey);
 247                     if (size <= 0) {
 248                         return CKMC_API_ERROR_INVALID_FORMAT;
 249                     }
 250                     output.resize(size);
 251
 252                         int type = EVP_PKEY_type(pkey->type);
 253                         ckmc_key_type key_type = CKMC_KEY_NONE;
 254                         switch(type) {
 255                         case EVP_PKEY_RSA :
 256                                 key_type = CKMC_KEY_RSA_PRIVATE;
 257                                 break;
 258                         case EVP_PKEY_EC :
 259                                 key_type = CKMC_KEY_ECDSA_PRIVATE;
 260                                 break;
 261                         }
 262                         if(key_type == CKMC_KEY_NONE) {
 263                                 return CKMC_API_ERROR_INVALID_FORMAT;
 264                         }
 265
 266                         char *nullPassword = NULL;
 267
 268                         retPrivateKey = ckmc_key_new(output.data(), size, key_type, nullPassword);
 269
 270                         return CKMC_API_SUCCESS;
 271                 }
 272
 273                 int toCaCkmCertList() {
 274                         X509* popedCert = NULL;
 275                         ckmc_cert *popedCkmCert = NULL;
 276                         ckmc_cert_list *tmpCertList = NULL;
 277                         while((popedCert = sk_X509_pop(ca)) != NULL) {
 278                                 if( (ret =_ckmc_load_cert_from_x509(popedCert, &popedCkmCert)) != CKMC_API_SUCCESS) {
 279                                         return CKMC_API_ERROR_OUT_OF_MEMORY;
 280                                 }
 281                                 if(tmpCertList == NULL) { // first
 282                                         tmpCertList = ckmc_cert_list_new(popedCkmCert);
 283                                         retCaCertList = tmpCertList;
 284                                 }else {
 285                                         tmpCertList = ckmc_cert_list_add(tmpCertList, popedCkmCert);
 286                                 }
 287                         }
 288                         return CKMC_API_SUCCESS;
 289                 }
 290
 291         };
 292
 293         int ret = CKMC_API_SUCCESS;
 294
 295         Pkcs12Converter converter;
 296         if((ret = converter.parsePkcs12(file_path, passphrase)) != CKMC_API_SUCCESS) {
 297                 return ret;
 298         }
 299         if((ret = converter.toCkmCert()) != CKMC_API_SUCCESS) {
 300                 return ret;
 301         }
 302         if((ret = converter.toCkmKey()) != CKMC_API_SUCCESS) {
 303                 return ret;
 304         }
 305         if((ret = converter.toCaCkmCertList()) != CKMC_API_SUCCESS) {
 306                 return ret;
 307         }
 308
 309         *private_key = converter.retPrivateKey;
 310         *ckmcert = converter.retCkmCert;
 311         *ca_cert_list = converter.retCaCertList;
 312
 313         return CKMC_API_SUCCESS;
 314 }
 315
 316 KEY_MANAGER_CAPI
 317 void ckmc_cert_free(ckmc_cert *cert)
 318 {
 319         if(cert == NULL)
 320                 return;
 321
 322         if(cert->raw_cert != NULL) {
 323                 memset(cert->raw_cert, 0, cert->cert_size);
 324                 free(cert->raw_cert);
 325         }
 326         free(cert);
 327 }
 328
 329 KEY_MANAGER_CAPI
 330 ckmc_alias_list *ckmc_alias_list_new(char *alias)
 331 {
 332         ckmc_alias_list *previous = NULL;
 333         return ckmc_alias_list_add(previous, alias);
 334 }
 335
 336 KEY_MANAGER_CAPI
 337 ckmc_alias_list *ckmc_alias_list_add(ckmc_alias_list *previous, char *alias)
 338 {
 339         ckmc_alias_list *plist = new ckmc_alias_list;
 340
 341         plist->alias = alias;
 342         plist->next = NULL;
 343
 344         if(previous != NULL)
 345                 previous->next = plist;
 346
 347         return plist;
 348 }
 349
 350 KEY_MANAGER_CAPI
 351 void ckmc_alias_list_free(ckmc_alias_list *first)
 352 {
 353         if(first == NULL)
 354                 return;
 355
 356         ckmc_alias_list *current = NULL;
 357         ckmc_alias_list *next = first;
 358         do {
 359                 current = next;
 360                 next = current->next;
 361                 free(current);
 362         }while(next != NULL);
 363 }
 364
 365 KEY_MANAGER_CAPI
 366 void ckmc_alias_list_all_free(ckmc_alias_list *first)
 367 {
 368         if(first == NULL)
 369                 return;
 370
 371         ckmc_alias_list *current = NULL;
 372         ckmc_alias_list *next = first;
 373         do {
 374                 current = next;
 375                 next = current->next;
 376                 if((current->alias)!=NULL) {
 377                         free(current->alias);
 378                 }
 379                 free(current);
 380         }while(next != NULL);
 381 }
 382
 383 KEY_MANAGER_CAPI
 384 ckmc_cert_list *ckmc_cert_list_new(ckmc_cert *cert)
 385 {
 386         ckmc_cert_list *previous = NULL;
 387         return ckmc_cert_list_add(previous, cert);
 388 }
 389
 390 KEY_MANAGER_CAPI
 391 ckmc_cert_list *ckmc_cert_list_add(ckmc_cert_list *previous, ckmc_cert *cert)
 392 {
 393         ckmc_cert_list *plist = new ckmc_cert_list;
 394
 395         plist->cert = cert;
 396         plist->next = NULL;
 397
 398         if(previous != NULL)
 399                 previous->next = plist;
 400
 401         return plist;
 402 }
 403
 404 KEY_MANAGER_CAPI
 405 void ckmc_cert_list_free(ckmc_cert_list *first)
 406 {
 407         if(first == NULL)
 408                 return;
 409
 410         ckmc_cert_list *current = NULL;
 411         ckmc_cert_list *next = first;
 412         do {
 413                 current = next;
 414                 next = current->next;
 415                 free(current);
 416         }while(next != NULL);
 417 }
 418
 419 KEY_MANAGER_CAPI
 420 void ckmc_cert_list_all_free(ckmc_cert_list *first)
 421 {
 422         if(first == NULL)
 423                 return;
 424
 425         ckmc_cert_list *current = NULL;
 426         ckmc_cert_list *next = first;
 427         do {
 428                 current = next;
 429                 next = current->next;
 430                 if((current->cert)!=NULL) {
 431                         ckmc_cert_free(current->cert);
 432                 }
 433                 free(current);
 434         }while(next != NULL);
 435 }
 436
 437 int _ckmc_load_cert_from_x509(X509 *xCert, ckmc_cert **cert)
 438 {
 439         if(xCert == NULL) {
 440                 return CKMC_API_ERROR_INVALID_FORMAT;
 441         }
 442
 443         BIO *bcert = BIO_new(BIO_s_mem());
 444
 445         i2d_X509_bio(bcert, xCert);
 446
 447     CKM::RawBuffer output(8196);
 448     int size = BIO_read(bcert, output.data(), output.size());
 449         BIO_free_all(bcert);
 450     if (size <= 0) {
 451         return CKMC_API_ERROR_INVALID_FORMAT;
 452     }
 453     output.resize(size);
 454
 455         *cert = ckmc_cert_new(output.data(), output.size(), CKMC_FORM_DER);
 456
 457         return CKMC_API_SUCCESS;
 458 }