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 #include <fstream>
  37
  38 namespace {
  39
  40 const size_t DEFAULT_IV_LEN = 16;
  41 const size_t DEFAULT_IV_LEN_BITS = 8*DEFAULT_IV_LEN;
  42 const size_t DEFAULT_KEY_LEN_BITS = 4096;
  43
  44 int _ckmc_random_buffer(ckmc_raw_buffer_s **buffer, size_t len)
  45 {
  46     if(!buffer)
  47         return CKMC_ERROR_INVALID_PARAMETER;
  48
  49     char* data = static_cast<char*>(malloc(len*sizeof(char)));
  50     if(!data)
  51         return CKMC_ERROR_OUT_OF_MEMORY;
  52
  53     std::ifstream is("/dev/urandom", std::ifstream::binary);
  54     if(!is) {
  55         free(data);
  56         return CKMC_ERROR_FILE_SYSTEM;
  57     }
  58
  59     is.read(data, len);
  60     if (static_cast<std::streamsize>(len) != is.gcount()) {
  61         free(data);
  62         return CKMC_ERROR_FILE_SYSTEM;
  63     }
  64
  65     return ckmc_buffer_new(reinterpret_cast<unsigned char*>(data), len, buffer);
  66 }
  67
  68 int _ckmc_load_cert_from_x509(X509 *xCert, ckmc_cert_s **cert)
  69 {
  70     if(xCert == NULL) {
  71         return CKMC_ERROR_INVALID_FORMAT;
  72     }
  73
  74     BIO *bcert = BIO_new(BIO_s_mem());
  75
  76     i2d_X509_bio(bcert, xCert);
  77
  78     CKM::RawBuffer output(8196);
  79     int size = BIO_read(bcert, output.data(), output.size());
  80     BIO_free_all(bcert);
  81     if (size <= 0) {
  82         return CKMC_ERROR_INVALID_FORMAT;
  83     }
  84     output.resize(size);
  85
  86     return ckmc_cert_new(output.data(), output.size(), CKMC_FORM_DER, cert);
  87 }
  88
  89 } // namespace anonymous
  90
  91
  92 const char * const ckmc_label_name_separator    = CKM::LABEL_NAME_SEPARATOR;
  93 const char * const ckmc_label_shared_owner      = CKM::LABEL_SYSTEM_DB;
  94
  95 KEY_MANAGER_CAPI
  96 int ckmc_key_new(unsigned char *raw_key, size_t key_size, ckmc_key_type_e key_type, char *password, ckmc_key_s **ppkey)
  97 {
  98     ckmc_key_s *pkey;
  99
 100     if(raw_key == NULL || key_size <= 0 || ppkey == NULL) {
 101         return CKMC_ERROR_INVALID_PARAMETER;
 102     }
 103
 104     pkey = static_cast<ckmc_key_s*>(malloc(sizeof(ckmc_key_s)));
 105     if(pkey == NULL) {
 106         return CKMC_ERROR_OUT_OF_MEMORY;
 107     }
 108     pkey->raw_key = reinterpret_cast<unsigned char*>(malloc(key_size));
 109     if(pkey->raw_key == NULL) {
 110         free(pkey);
 111         return CKMC_ERROR_OUT_OF_MEMORY;
 112     }
 113     memcpy(pkey->raw_key, raw_key, key_size);
 114
 115     pkey->key_size = key_size;
 116     pkey->key_type = key_type;
 117
 118     if(password != NULL) {
 119         pkey->password = reinterpret_cast<char*>(malloc(strlen(password) +1));
 120         if(pkey->password == NULL) {
 121             free(pkey->raw_key);
 122             free(pkey);
 123             return CKMC_ERROR_OUT_OF_MEMORY;
 124         }
 125         memset(pkey->password, 0, strlen(password) +1);
 126         strncpy(pkey->password, password, strlen(password));
 127     }else {
 128         pkey->password = NULL;
 129     }
 130
 131     *ppkey = pkey;
 132
 133     return CKMC_ERROR_NONE;
 134 }
 135
 136 KEY_MANAGER_CAPI
 137 void ckmc_key_free(ckmc_key_s *key)
 138 {
 139     if(key == NULL)
 140         return;
 141
 142     if(key->password != NULL)
 143         free(key->password);
 144     if(key->raw_key != NULL) {
 145         memset(key->raw_key, 0, key->key_size);
 146         free(key->raw_key);
 147     }
 148
 149     free(key);
 150 }
 151
 152 KEY_MANAGER_CAPI
 153 int ckmc_buffer_new(unsigned char *data, size_t size,ckmc_raw_buffer_s **ppbuffer)
 154 {
 155     ckmc_raw_buffer_s *pbuff;
 156
 157     if(data == NULL || size <= 0 || ppbuffer == NULL) {
 158         return CKMC_ERROR_INVALID_PARAMETER;
 159     }
 160
 161     pbuff = static_cast<ckmc_raw_buffer_s*>(malloc(sizeof(ckmc_raw_buffer_s)));
 162     if(pbuff == NULL)
 163             return CKMC_ERROR_OUT_OF_MEMORY;
 164
 165     pbuff->data = reinterpret_cast<unsigned char*>(malloc(size));
 166     if(pbuff->data == NULL) {
 167         free(pbuff);
 168         return CKMC_ERROR_OUT_OF_MEMORY;
 169     }
 170     memcpy(pbuff->data, data, size);
 171
 172     pbuff->size = size;
 173     *ppbuffer = pbuff;
 174
 175     return CKMC_ERROR_NONE;
 176 }
 177
 178 KEY_MANAGER_CAPI
 179 void ckmc_buffer_free(ckmc_raw_buffer_s *buffer)
 180 {
 181     if(buffer == NULL)
 182         return;
 183
 184     if(buffer->data != NULL) {
 185         memset(buffer->data, 0, buffer->size);
 186         free(buffer->data);
 187     }
 188     free(buffer);
 189 }
 190
 191 KEY_MANAGER_CAPI
 192 int ckmc_cert_new(unsigned char *raw_cert, size_t cert_size, ckmc_data_format_e data_format, ckmc_cert_s **ppcert)
 193 {
 194     ckmc_cert_s *pcert;
 195
 196     if(raw_cert == NULL || cert_size <= 0 || ppcert == NULL) {
 197         return CKMC_ERROR_INVALID_PARAMETER;
 198     }
 199
 200     pcert = static_cast<ckmc_cert_s*>(malloc(sizeof(ckmc_cert_s)));
 201     if(pcert == NULL) {
 202         return CKMC_ERROR_OUT_OF_MEMORY;
 203     }
 204     pcert->raw_cert = reinterpret_cast<unsigned char*>(malloc(cert_size));
 205     if(pcert->raw_cert == NULL) {
 206         free(pcert);
 207         return CKMC_ERROR_OUT_OF_MEMORY;
 208     }
 209     memcpy(pcert->raw_cert, raw_cert, cert_size);
 210
 211     pcert->cert_size = cert_size;
 212     pcert->data_format = data_format;
 213
 214     *ppcert = pcert;
 215     return CKMC_ERROR_NONE;
 216 }
 217
 218 KEY_MANAGER_CAPI
 219 int ckmc_load_cert_from_file(const char *file_path, ckmc_cert_s **cert)
 220 {
 221     OpenSSL_add_all_algorithms();
 222
 223     FILE *fp = fopen(file_path, "r");
 224     if(fp == NULL)
 225         return CKMC_ERROR_FILE_ACCESS_DENIED;
 226     X509 *pcert = NULL;
 227     if(!(pcert = d2i_X509_fp(fp, NULL))) {
 228         fseek(fp, 0, SEEK_SET);
 229         pcert = PEM_read_X509(fp, NULL, NULL, NULL);
 230     }
 231     fclose(fp);
 232     if(pcert == NULL) {
 233         return CKMC_ERROR_INVALID_FORMAT;
 234     }
 235
 236     int ret = _ckmc_load_cert_from_x509(pcert, cert);
 237     if(ret != CKMC_ERROR_NONE) {
 238         X509_free(pcert);
 239     }
 240     return ret;
 241 }
 242
 243 KEY_MANAGER_CAPI
 244 void ckmc_cert_free(ckmc_cert_s *cert)
 245 {
 246     if(cert == NULL)
 247         return;
 248
 249     if(cert->raw_cert != NULL) {
 250         memset(cert->raw_cert, 0, cert->cert_size);
 251         free(cert->raw_cert);
 252     }
 253     free(cert);
 254 }
 255
 256 KEY_MANAGER_CAPI
 257 int ckmc_pkcs12_new(ckmc_key_s *private_key, ckmc_cert_s *cert,
 258         ckmc_cert_list_s *ca_cert_list, ckmc_pkcs12_s **pkcs12_bundle)
 259 {
 260     ckmc_pkcs12_s *pkcs12;
 261
 262     if(!pkcs12_bundle ||
 263        (private_key==NULL && cert==NULL && (ca_cert_list==NULL || ca_cert_list->cert==NULL))) {
 264         return CKMC_ERROR_INVALID_PARAMETER;
 265     }
 266
 267     pkcs12 = static_cast<ckmc_pkcs12_s*>(malloc(sizeof(ckmc_pkcs12_s)));
 268     if(pkcs12 == NULL) {
 269         return CKMC_ERROR_OUT_OF_MEMORY;
 270     }
 271     // ownership is transferred into pkcs12 - mentioned in the docs
 272     pkcs12->priv_key = private_key;
 273     pkcs12->cert = cert;
 274     pkcs12->ca_chain = ca_cert_list;
 275
 276     *pkcs12_bundle = pkcs12;
 277     return CKMC_ERROR_NONE;
 278 }
 279
 280 KEY_MANAGER_CAPI
 281 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)
 282 {
 283     class Pkcs12Converter {
 284     private:
 285         FILE* fp_in;
 286         PKCS12* p12;
 287         EVP_PKEY* pkey;
 288         X509* x509Cert;
 289         STACK_OF(X509)* ca;
 290
 291         int ret;
 292     public:
 293         ckmc_key_s *retPrivateKey;
 294         ckmc_cert_s *retCkmCert;
 295         ckmc_cert_list_s *retCaCertList;
 296
 297         Pkcs12Converter(){
 298             fp_in = NULL;
 299             p12 = NULL;
 300             pkey = NULL;
 301             x509Cert = NULL;
 302             ca = NULL;
 303             ret = CKMC_ERROR_NONE;
 304             retPrivateKey = NULL;
 305             retCkmCert = NULL;
 306             retCaCertList = NULL;
 307         };
 308         ~Pkcs12Converter(){
 309             if(fp_in != NULL)
 310                 fclose(fp_in);
 311             if(p12 != NULL)
 312                 PKCS12_free(p12);
 313             if(x509Cert != NULL)
 314                 X509_free(x509Cert);
 315             if(pkey != NULL)
 316                 EVP_PKEY_free(pkey);
 317             if(ca != NULL)
 318                 sk_X509_pop_free(ca, X509_free);
 319
 320             if(ret != CKMC_ERROR_NONE) {
 321                 if(retPrivateKey != NULL){
 322                     ckmc_key_free(retPrivateKey);
 323                     retPrivateKey = NULL;
 324                 }
 325                 if(retCkmCert != NULL) {
 326                     ckmc_cert_free(retCkmCert);
 327                     retCkmCert = NULL;
 328                 }
 329                 if(retCaCertList != NULL) {
 330                     ckmc_cert_list_all_free(retCaCertList);
 331                     retCaCertList = NULL;
 332                 }
 333             }
 334         };
 335
 336         int parsePkcs12(const char *filePath, const char *pass) {
 337             fp_in = NULL;
 338             if(!(fp_in = fopen(filePath, "rb"))) {
 339                 return CKMC_ERROR_FILE_ACCESS_DENIED;
 340             }
 341
 342             if(!(p12 = d2i_PKCS12_fp(fp_in, NULL))) {
 343                 return CKMC_ERROR_INVALID_FORMAT;
 344             }
 345
 346             /* parse PKCS#12 certificate */
 347             if((ret = PKCS12_parse(p12, pass, &pkey, &x509Cert, &ca)) != 1) {
 348                 return CKMC_ERROR_INVALID_FORMAT;
 349             }
 350             return CKMC_ERROR_NONE;
 351         }
 352
 353         int toCkmCert() {
 354             if( (ret =_ckmc_load_cert_from_x509(x509Cert,&retCkmCert)) != CKMC_ERROR_NONE) {
 355                 return ret;
 356             }
 357             return CKMC_ERROR_NONE;
 358         }
 359
 360         int toCkmKey() {
 361             BIO *bkey = BIO_new(BIO_s_mem());
 362
 363             i2d_PrivateKey_bio(bkey, pkey);
 364
 365             CKM::RawBuffer output(8196);
 366             int size = BIO_read(bkey, output.data(), output.size());
 367             BIO_free_all(bkey);
 368             if (size <= 0) {
 369                 return CKMC_ERROR_INVALID_FORMAT;
 370             }
 371             output.resize(size);
 372
 373             int type = EVP_PKEY_type(pkey->type);
 374             ckmc_key_type_e key_type = CKMC_KEY_NONE;
 375             switch(type) {
 376             case EVP_PKEY_RSA :
 377                 key_type = CKMC_KEY_RSA_PRIVATE;
 378                 break;
 379             case EVP_PKEY_DSA :
 380                 key_type = CKMC_KEY_DSA_PRIVATE;
 381                 break;
 382             case EVP_PKEY_EC :
 383                 key_type = CKMC_KEY_ECDSA_PRIVATE;
 384                 break;
 385             }
 386             if(key_type == CKMC_KEY_NONE) {
 387                 return CKMC_ERROR_INVALID_FORMAT;
 388             }
 389
 390             char *nullPassword = NULL;
 391
 392             return ckmc_key_new(output.data(), size, key_type, nullPassword, &retPrivateKey);
 393         }
 394
 395         int toCaCkmCertList() {
 396             int tmpRet;
 397             X509* popedCert = NULL;
 398             ckmc_cert_s *popedCkmCert = NULL;
 399             ckmc_cert_list_s *tmpCertList = NULL;
 400             while((popedCert = sk_X509_pop(ca)) != NULL) {
 401                 if( (tmpRet =_ckmc_load_cert_from_x509(popedCert, &popedCkmCert)) != CKMC_ERROR_NONE) {
 402                     return CKMC_ERROR_OUT_OF_MEMORY;
 403                 }
 404                 if(tmpCertList == NULL) { // first
 405                     tmpRet = ckmc_cert_list_new(popedCkmCert, &tmpCertList);
 406                     retCaCertList = tmpCertList;
 407                 }else {
 408                     tmpRet = ckmc_cert_list_add(tmpCertList, popedCkmCert, &tmpCertList);
 409                 }
 410                 if(tmpRet != CKMC_ERROR_NONE) {
 411                     ckmc_cert_list_all_free(retCaCertList);
 412                     retCaCertList = NULL;
 413                     return tmpRet;
 414                 }
 415             }
 416             return CKMC_ERROR_NONE;
 417         }
 418
 419     };
 420
 421     OpenSSL_add_all_algorithms();
 422
 423     int ret = CKMC_ERROR_NONE;
 424
 425     Pkcs12Converter converter;
 426     if((ret = converter.parsePkcs12(file_path, passphrase)) != CKMC_ERROR_NONE) {
 427         return ret;
 428     }
 429     if((ret = converter.toCkmCert()) != CKMC_ERROR_NONE) {
 430         return ret;
 431     }
 432     if((ret = converter.toCkmKey()) != CKMC_ERROR_NONE) {
 433         return ret;
 434     }
 435     if((ret = converter.toCaCkmCertList()) != CKMC_ERROR_NONE) {
 436         return ret;
 437     }
 438
 439     *private_key = converter.retPrivateKey;
 440     *ckmcert = converter.retCkmCert;
 441     *ca_cert_list = converter.retCaCertList;
 442
 443     return CKMC_ERROR_NONE;
 444 }
 445
 446 KEY_MANAGER_CAPI
 447 int ckmc_pkcs12_load(const char *file_path, const char *passphrase, ckmc_pkcs12_s **pkcs12_bundle)
 448 {
 449     int ec;
 450     ckmc_key_s *private_key = 0;
 451     ckmc_cert_s *cert = 0;
 452     ckmc_cert_list_s *ca_cert_list = 0;
 453
 454     if(!file_path || !pkcs12_bundle)
 455         return CKMC_ERROR_INVALID_PARAMETER;
 456
 457     ec = ckmc_load_from_pkcs12_file(file_path, passphrase, &private_key, &cert, &ca_cert_list);
 458     if(ec != CKMC_ERROR_NONE)
 459         return ec;
 460
 461     ec = ckmc_pkcs12_new(private_key, cert, ca_cert_list, pkcs12_bundle);
 462     if(ec != CKMC_ERROR_NONE)
 463     {
 464         ckmc_key_free(private_key);
 465         ckmc_cert_free(cert);
 466         ckmc_cert_list_free(ca_cert_list);
 467         return ec;
 468     }
 469
 470     return CKMC_ERROR_NONE;
 471 }
 472
 473 KEY_MANAGER_CAPI
 474 void ckmc_pkcs12_free(ckmc_pkcs12_s *pkcs12)
 475 {
 476     if(pkcs12 == NULL)
 477         return;
 478
 479     ckmc_key_free(pkcs12->priv_key);
 480     ckmc_cert_free(pkcs12->cert);
 481     ckmc_cert_list_free(pkcs12->ca_chain);
 482     free(pkcs12);
 483 }
 484
 485 KEY_MANAGER_CAPI
 486 int ckmc_alias_list_new(char *alias, ckmc_alias_list_s **ppalias_list)
 487 {
 488     ckmc_alias_list_s *previous = NULL;
 489     return ckmc_alias_list_add(previous, alias, ppalias_list);
 490 }
 491
 492 KEY_MANAGER_CAPI
 493 int ckmc_alias_list_add(ckmc_alias_list_s *previous, char *alias, ckmc_alias_list_s **pplast)
 494 {
 495     ckmc_alias_list_s *plist;
 496
 497     if(alias == NULL || pplast == NULL) {
 498         return CKMC_ERROR_INVALID_PARAMETER;
 499     }
 500
 501     plist = static_cast<ckmc_alias_list_s*>(malloc(sizeof(ckmc_alias_list_s)));
 502     if(plist == NULL) {
 503         return CKMC_ERROR_OUT_OF_MEMORY;
 504     }
 505
 506     plist->alias = alias;
 507     plist->next = NULL;
 508
 509     if(previous != NULL) {
 510         previous->next = plist;
 511     }
 512     *pplast = plist;
 513
 514     return CKMC_ERROR_NONE;
 515 }
 516
 517 KEY_MANAGER_CAPI
 518 void ckmc_alias_list_free(ckmc_alias_list_s *first)
 519 {
 520     ckmc_alias_list_s *next = first;
 521     while (next) {
 522         ckmc_alias_list_s *current = next;
 523         next = current->next;
 524         free(current);
 525     }
 526 }
 527
 528 KEY_MANAGER_CAPI
 529 void ckmc_alias_list_all_free(ckmc_alias_list_s *first)
 530 {
 531     ckmc_alias_list_s *next = first;
 532     while (next) {
 533         ckmc_alias_list_s *current = next;
 534         next = current->next;
 535         free(current->alias);
 536         free(current);
 537     }
 538 }
 539
 540 KEY_MANAGER_CAPI
 541 int ckmc_cert_list_new(ckmc_cert_s *cert, ckmc_cert_list_s **ppalias_list)
 542 {
 543     ckmc_cert_list_s *previous = NULL;
 544     return ckmc_cert_list_add(previous, cert, ppalias_list);
 545 }
 546
 547 KEY_MANAGER_CAPI
 548 int ckmc_cert_list_add(ckmc_cert_list_s *previous, ckmc_cert_s *cert, ckmc_cert_list_s **pplast)
 549 {
 550     ckmc_cert_list_s *plist;
 551
 552     if(cert == NULL || pplast == NULL) {
 553         return CKMC_ERROR_INVALID_PARAMETER;
 554     }
 555
 556     plist = static_cast<ckmc_cert_list_s*>(malloc(sizeof(ckmc_cert_list_s)));
 557     if(plist == NULL) {
 558         return CKMC_ERROR_OUT_OF_MEMORY;
 559     }
 560     plist->cert = cert;
 561     plist->next = NULL;
 562
 563     if(previous != NULL) {
 564         previous->next = plist;
 565     }
 566
 567     *pplast = plist;
 568
 569     return CKMC_ERROR_NONE;
 570 }
 571
 572 KEY_MANAGER_CAPI
 573 void ckmc_cert_list_free(ckmc_cert_list_s *first)
 574 {
 575     ckmc_cert_list_s *next = first;
 576     while (next) {
 577         ckmc_cert_list_s *current = next;
 578         next = current->next;
 579         free(current);
 580     }
 581 }
 582
 583 KEY_MANAGER_CAPI
 584 void ckmc_cert_list_all_free(ckmc_cert_list_s *first)
 585 {
 586     ckmc_cert_list_s *next = first;
 587     while (next) {
 588         ckmc_cert_list_s *current = next;
 589         next = current->next;
 590         ckmc_cert_free(current->cert);
 591         free(current);
 592     }
 593 }
 594
 595 KEY_MANAGER_CAPI
 596 int ckmc_param_list_new(ckmc_param_list_s **ppparams)
 597 {
 598     if (!ppparams)
 599         return CKMC_ERROR_INVALID_PARAMETER;
 600
 601     *ppparams = reinterpret_cast<ckmc_param_list_s*>(new(std::nothrow)(CKM::CryptoAlgorithm));
 602     if (!*ppparams)
 603         return CKMC_ERROR_OUT_OF_MEMORY;
 604     return CKMC_ERROR_NONE;
 605 }
 606
 607 KEY_MANAGER_CAPI
 608 int ckmc_param_list_add_integer(ckmc_param_list_s *params,
 609                                 ckmc_param_name_e name,
 610                                 uint64_t value)
 611 {
 612     if (!params)
 613         return CKMC_ERROR_INVALID_PARAMETER;
 614
 615     CKM::CryptoAlgorithm* algo = reinterpret_cast<CKM::CryptoAlgorithm*>(params);
 616     bool ret = algo->addParam(static_cast<CKM::ParamName>(name), value);
 617     return (ret ? CKMC_ERROR_NONE : CKMC_ERROR_INVALID_PARAMETER);
 618 }
 619
 620 KEY_MANAGER_CAPI
 621 int ckmc_param_list_add_buffer(ckmc_param_list_s *params,
 622                                ckmc_param_name_e name,
 623                                const ckmc_raw_buffer_s *buffer)
 624 {
 625     if (!params || !buffer || !buffer->data || buffer->size == 0)
 626         return CKMC_ERROR_INVALID_PARAMETER;
 627
 628     CKM::CryptoAlgorithm* algo = reinterpret_cast<CKM::CryptoAlgorithm*>(params);
 629     CKM::RawBuffer b(buffer->data, buffer->data + buffer->size);
 630     bool ret =  algo->addParam(static_cast<CKM::ParamName>(name), b);
 631     return (ret ? CKMC_ERROR_NONE : CKMC_ERROR_INVALID_PARAMETER);
 632 }
 633
 634 KEY_MANAGER_CAPI
 635 void ckmc_param_list_free(ckmc_param_list_s *params)
 636 {
 637     CKM::CryptoAlgorithm* algo = reinterpret_cast<CKM::CryptoAlgorithm*>(params);
 638     delete algo;
 639 }
 640
 641 KEY_MANAGER_CAPI
 642 int ckmc_generate_params(ckmc_algo_type_e type, ckmc_param_list_s *params)
 643 {
 644     // return error if params are NULL
 645     if(params == NULL)
 646         return CKMC_ERROR_INVALID_PARAMETER;
 647
 648     ckmc_raw_buffer_s* buffer = NULL;
 649     int ret = CKMC_ERROR_NONE;
 650     switch(type)
 651     {
 652     case CKMC_ALGO_AES_CTR:
 653         ret = ckmc_param_list_add_integer(params, CKMC_PARAM_ED_CTR_LEN, DEFAULT_IV_LEN_BITS);
 654         // no break on purpose
 655     case CKMC_ALGO_AES_CBC:
 656     case CKMC_ALGO_AES_GCM:
 657     case CKMC_ALGO_AES_CFB:
 658         if (ret == CKMC_ERROR_NONE)
 659             ret = _ckmc_random_buffer(&buffer, DEFAULT_IV_LEN);
 660         if (ret == CKMC_ERROR_NONE)
 661             ret = ckmc_param_list_add_buffer(params, CKMC_PARAM_ED_IV, buffer);
 662         else
 663             ckmc_buffer_free(buffer);
 664         break;
 665     case CKMC_ALGO_RSA_OAEP:
 666         break;
 667     case CKMC_ALGO_RSA_SV:
 668     case CKMC_ALGO_DSA_SV:
 669     case CKMC_ALGO_ECDSA_SV:
 670         // no hash, no padding by default
 671         break;
 672     case CKMC_ALGO_RSA_GEN:
 673     case CKMC_ALGO_DSA_GEN:
 674         ret = ckmc_param_list_add_integer(params, CKMC_PARAM_GEN_KEY_LEN, DEFAULT_KEY_LEN_BITS);
 675         break;
 676     case CKMC_ALGO_ECDSA_GEN:
 677         ret = ckmc_param_list_add_integer(params, CKMC_PARAM_GEN_EC, CKMC_EC_PRIME192V1);
 678         break;
 679     default:
 680         return CKMC_ERROR_INVALID_PARAMETER;
 681     }
 682     if (ret == CKMC_ERROR_NONE)
 683         return ckmc_param_list_add_integer(params, CKMC_PARAM_ALGO_TYPE, type);
 684     return ret;
 685 }