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

   1 /*
   2  *  Copyright (c) 2000 - 2019 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-manager.cpp
  18  * @author      Yuseok Jeon(yuseok.jeon@samsung.com)
  19  * @version     1.0
  20  * @brief       Wrap C++ functions to provide C APIs
  21  */
  22
  23 #include <dpl/log/log.h>
  24 #include <ckm/ckm-type.h>
  25 #include <ckm/ckm-manager.h>
  26 #include <ckmc/ckmc-type.h>
  27 #include <ckmc/ckmc-manager.h>
  28 #include <ckmc/ckmc-error.h>
  29 #include <ckmc-type-converter.h>
  30 #include <client-common.h>
  31 #include <functional>
  32 #include <iostream>
  33 #include <string.h>
  34
  35 namespace {
  36 const CKM::CertificateShPtrVector EMPTY_CERT_VECTOR;
  37 const CKM::AliasVector EMPTY_ALIAS_VECTOR;
  38
  39 int _ckmc_alias_info_new(const char* alias, bool is_password_protected, ckmc_alias_info_s** info)
  40 {
  41         if (alias == NULL)
  42                 return CKMC_ERROR_SERVER_ERROR;
  43         if (info == NULL)
  44                 return CKMC_ERROR_UNKNOWN;
  45
  46         ckmc_alias_info_s* _info = NULL;
  47         _info = static_cast<ckmc_alias_info_s*>(malloc(sizeof(ckmc_alias_info_s)));
  48
  49         if (_info == NULL)
  50                 return CKMC_ERROR_OUT_OF_MEMORY;
  51
  52         _info->alias = strdup(alias);
  53         if (_info->alias == NULL)
  54         {
  55                 free(_info);
  56                 return CKMC_ERROR_OUT_OF_MEMORY;
  57         }
  58         _info->is_password_protected = is_password_protected;
  59         *info = _info;
  60         return CKMC_ERROR_NONE;
  61 }
  62
  63 inline CKM::Password _tostring(const char *str)
  64 {
  65         return (str == nullptr) ? CKM::Password() : CKM::Password(str);
  66 }
  67
  68 inline CKM::Policy _toCkmPolicy(const ckmc_policy_s &policy)
  69 {
  70         return CKM::Policy(_tostring(policy.password), policy.extractable);
  71 }
  72
  73 CKM::KeyShPtr _toCkmKey(const ckmc_key_s *key)
  74 {
  75         if (key == nullptr)
  76                 return CKM::KeyShPtr();
  77
  78         auto ckmKey = CKM::Key::create(
  79                            CKM::RawBuffer(key->raw_key, key->raw_key + key->key_size),
  80                            _tostring(key->password));
  81
  82         if (!ckmKey || ckmKey->empty())
  83                 ThrowMsg(CKM::Exc::InvalidFormat, "Key parsing failed");
  84
  85         return ckmKey;
  86 }
  87
  88 CKM::CertificateShPtr _toCkmCertificate(const ckmc_cert_s *cert)
  89 {
  90         if (cert == nullptr)
  91                 return CKM::CertificateShPtr();
  92
  93         auto ckmCert = CKM::Certificate::create(
  94                            CKM::RawBuffer(cert->raw_cert, cert->raw_cert + cert->cert_size),
  95                            static_cast<CKM::DataFormat>(static_cast<int>(cert->data_format)));
  96
  97         if (!ckmCert || ckmCert->empty())
  98                 ThrowMsg(CKM::Exc::InvalidFormat, "Certificate parsing failed");
  99
 100         return ckmCert;
 101 }
 102
 103 CKM::CertificateShPtrVector _toCkmCertificateVector(const ckmc_cert_list_s
 104                 *list)
 105 {
 106         CKM::CertificateShPtrVector certs;
 107         auto current = list;
 108
 109         while (current != nullptr) {
 110                 if (current->cert != nullptr)
 111                         certs.emplace_back(_toCkmCertificate(current->cert));
 112
 113                 current = current->next;
 114         }
 115
 116         return certs;
 117 }
 118
 119 CKM::AliasVector _toCkmAliasVector(const ckmc_alias_list_s *list)
 120 {
 121         CKM::AliasVector aliases;
 122         auto current = list;
 123
 124         while (current != nullptr) {
 125                 if (current->alias != nullptr)
 126                         aliases.emplace_back(CKM::Alias(current->alias));
 127
 128                 current = current->next;
 129         }
 130
 131         return aliases;
 132 }
 133
 134 ckmc_cert_list_s *_toNewCkmCertList(const CKM::CertificateShPtrVector
 135                                                                         &certVector)
 136 {
 137         ckmc_cert_list_s *start = nullptr;
 138         ckmc_cert_list_s *plist = nullptr;
 139
 140         for (const auto &e : certVector) {
 141                 if (!e || e->empty())
 142                         ThrowMsg(CKM::Exc::BadResponse, "Empty certificate received from server");
 143
 144                 auto rawBuffer = e->getDER();
 145                 ckmc_cert_s *pcert = nullptr;
 146                 int ret = ckmc_cert_new(rawBuffer.data(), rawBuffer.size(), CKMC_FORM_DER,
 147                                                                 &pcert);
 148
 149                 if (ret != CKMC_ERROR_NONE || pcert == nullptr) {
 150                         ckmc_cert_list_all_free(start);
 151                         return nullptr;
 152                 }
 153
 154                 ret = ckmc_cert_list_add(plist, pcert, &plist);
 155
 156                 if (ret != CKMC_ERROR_NONE) {
 157                         ckmc_cert_free(pcert);
 158                         ckmc_cert_list_all_free(start);
 159                         return nullptr;
 160                 }
 161
 162                 if (start == nullptr)
 163                         start = plist;
 164         }
 165
 166         return start;
 167 }
 168
 169 typedef int (CKM::Manager::*cryptoFn)(const CKM::CryptoAlgorithm &,
 170                                                                           const CKM::Alias &,
 171                                                                           const CKM::Password &,
 172                                                                           const CKM::RawBuffer &,
 173                                                                           CKM::RawBuffer &);
 174
 175 int _cryptoOperation(cryptoFn operation,
 176                                          ckmc_param_list_h params,
 177                                          const char *key_alias,
 178                                          const char *password,
 179                                          const ckmc_raw_buffer_s in,
 180                                          ckmc_raw_buffer_s **ppout)
 181 {
 182         if (!params || !key_alias || !ppout)
 183                 return CKMC_ERROR_INVALID_PARAMETER;
 184
 185         // params
 186         const CKM::CryptoAlgorithm *ca = reinterpret_cast<const CKM::CryptoAlgorithm *>
 187                                                                          (params);
 188
 189         // password
 190         CKM::Password pass;
 191
 192         if (password)
 193                 pass = password;
 194
 195         // buffers
 196         CKM::RawBuffer inBuffer(in.data, in.data + in.size);
 197         CKM::RawBuffer outBuffer;
 198
 199         auto mgr = CKM::Manager::create();
 200         int ret = ((*mgr).*operation)(*ca, key_alias, pass, inBuffer, outBuffer);
 201
 202         if (ret != CKM_API_SUCCESS)
 203                 return to_ckmc_error(ret);
 204
 205         return ckmc_buffer_new(outBuffer.data(), outBuffer.size(), ppout);
 206 }
 207
 208 int _toNewCkmcAliasInfoList(const CKM::AliasPwdVector &aliasPwdVector,
 209                 ckmc_alias_info_list_s **alias_info_list)
 210 {
 211         int ret = CKMC_ERROR_NONE;
 212
 213         if (alias_info_list == nullptr)
 214                 return CKMC_ERROR_UNKNOWN;
 215
 216         if (aliasPwdVector.size() == 0)
 217                 return CKMC_ERROR_DB_ALIAS_UNKNOWN;
 218
 219         ckmc_alias_info_list_s *start = nullptr;
 220         ckmc_alias_info_list_s *plist = nullptr;
 221         ckmc_alias_info_list_s *previous = nullptr;
 222
 223         for (const auto &it : aliasPwdVector) {
 224
 225                 previous = plist;
 226
 227                 plist = static_cast<ckmc_alias_info_list_s*>(calloc(1, sizeof(ckmc_alias_info_list_s)));
 228
 229                 if (plist == nullptr)
 230                 {
 231                         ret = CKMC_ERROR_OUT_OF_MEMORY;
 232                         break;
 233                 }
 234
 235                 if (start == nullptr)
 236                         start = plist;
 237
 238                 if (previous != nullptr)
 239                         previous->next = plist;
 240
 241                 if ((ret = _ckmc_alias_info_new(std::get<0>(it).c_str(), std::get<1>(it),
 242                                                 &plist->info) != CKMC_ERROR_NONE))
 243                 {
 244                         break;
 245                 }
 246
 247         }
 248
 249         if (ret != CKMC_ERROR_NONE)
 250         {
 251                 ckmc_alias_info_list_all_free(start);
 252                 return ret;
 253         }
 254
 255         *alias_info_list = start;
 256
 257         return CKMC_ERROR_NONE;
 258 }
 259
 260 int ckmc_generic_get_alias_info_list_helper(ckmc_alias_info_list_s **alias_info_list,
 261                 int(CKM::Manager::*func)(CKM::AliasPwdVector&))
 262 {
 263         EXCEPTION_GUARD_START_CAPI
 264
 265         auto mgr = CKM::Manager::create();
 266         int ret;
 267
 268         if (alias_info_list == nullptr)
 269                 return CKMC_ERROR_INVALID_PARAMETER;
 270
 271         CKM::AliasPwdVector aliasPwdVector;
 272
 273         if ((ret = ((*mgr).*func)(aliasPwdVector)) != CKM_API_SUCCESS)
 274                 return to_ckmc_error(ret);
 275
 276         if ((ret = _toNewCkmcAliasInfoList(aliasPwdVector, alias_info_list)) != CKM_API_SUCCESS)
 277                 return ret;
 278
 279         return CKMC_ERROR_NONE;
 280
 281         EXCEPTION_GUARD_END
 282 }
 283
 284 } // namespace anonymous
 285
 286 KEY_MANAGER_CAPI
 287 int ckmc_save_key(const char *alias, const ckmc_key_s key,
 288                                   const ckmc_policy_s policy)
 289 {
 290         EXCEPTION_GUARD_START_CAPI
 291
 292         auto mgr = CKM::Manager::create();
 293
 294         if (alias == nullptr || key.raw_key == nullptr || key.key_size == 0)
 295                 return CKMC_ERROR_INVALID_PARAMETER;
 296
 297         CKM::RawBuffer buffer(key.raw_key, key.raw_key + key.key_size);
 298         CKM::KeyShPtr ckmKey;
 299
 300         if (key.key_type == CKMC_KEY_AES) {
 301                 if (key.password)
 302                         return CKMC_ERROR_INVALID_PARAMETER;
 303
 304                 ckmKey = CKM::Key::createAES(buffer);
 305         } else {
 306                 ckmKey = CKM::Key::create(buffer, _tostring(key.password));
 307         }
 308
 309         if (!ckmKey)
 310                 return CKMC_ERROR_INVALID_FORMAT;
 311
 312         return to_ckmc_error(mgr->saveKey(CKM::Alias(alias), ckmKey,
 313                                                                           _toCkmPolicy(policy)));
 314
 315         EXCEPTION_GUARD_END
 316 }
 317
 318
 319 KEY_MANAGER_CAPI
 320 int ckmc_remove_key(const char *alias)
 321 {
 322         LogWarning("DEPRECATION WARNING: " << __func__ << "() is deprecated and will be "
 323                            "removed from next release. Use ckmc_remove_alias() instead.");
 324         return ckmc_remove_alias(alias);
 325 }
 326
 327 KEY_MANAGER_CAPI
 328 int ckmc_get_key(const char *alias, const char *password, ckmc_key_s **key)
 329 {
 330         EXCEPTION_GUARD_START_CAPI
 331
 332         if (alias == nullptr || key == nullptr)
 333                 return CKMC_ERROR_INVALID_PARAMETER;
 334
 335         int ret;
 336         CKM::KeyShPtr ckmKey;
 337         auto mgr = CKM::Manager::create();
 338
 339         if ((ret = mgr->getKey(alias, _tostring(password), ckmKey)) != CKM_API_SUCCESS)
 340                 return to_ckmc_error(ret);
 341
 342         if (!ckmKey || ckmKey->empty())
 343                 return CKMC_ERROR_BAD_RESPONSE;
 344
 345         auto buffer = ckmKey->getDER();
 346         return ckmc_key_new(
 347                            buffer.data(),
 348                            buffer.size(),
 349                            static_cast<ckmc_key_type_e>(static_cast<int>(ckmKey->getType())),
 350                            nullptr,
 351                            key);
 352
 353         EXCEPTION_GUARD_END
 354 }
 355
 356 KEY_MANAGER_CAPI
 357 int ckmc_get_key_alias_list(ckmc_alias_list_s **alias_list)
 358 {
 359         EXCEPTION_GUARD_START_CAPI
 360
 361         int ret;
 362
 363         if (alias_list == nullptr)
 364                 return CKMC_ERROR_INVALID_PARAMETER;
 365
 366         CKM::AliasVector aliasVector;
 367         auto mgr = CKM::Manager::create();
 368
 369         if ((ret = mgr->getKeyAliasVector(aliasVector)) != CKM_API_SUCCESS)
 370                 return to_ckmc_error(ret);
 371
 372         ckmc_alias_list_s *start = nullptr;
 373         ckmc_alias_list_s *plist = nullptr;
 374
 375         for (const auto &it : aliasVector) {
 376                 char *alias = strndup(it.c_str(), it.size());
 377
 378                 ret = ckmc_alias_list_add(plist, alias, &plist);
 379
 380                 if (ret != CKMC_ERROR_NONE) {
 381                         free(alias);
 382                         ckmc_alias_list_all_free(start);
 383                         return ret;
 384                 }
 385
 386                 if (start == nullptr)
 387                         start = plist;
 388         }
 389
 390         if (plist == nullptr) // if the alias_list size is zero
 391                 return CKMC_ERROR_DB_ALIAS_UNKNOWN;
 392
 393         *alias_list = start;
 394
 395         return CKMC_ERROR_NONE;
 396
 397         EXCEPTION_GUARD_END
 398 }
 399
 400
 401 KEY_MANAGER_CAPI
 402 int ckmc_get_key_alias_info_list(ckmc_alias_info_list_s **alias_info_list)
 403 {
 404
 405         return ckmc_generic_get_alias_info_list_helper(alias_info_list,
 406                         &CKM::Manager::getKeyAliasPwdVector);
 407 }
 408
 409 KEY_MANAGER_CAPI
 410 int ckmc_save_cert(const char *alias, const ckmc_cert_s cert,
 411                                    const ckmc_policy_s policy)
 412 {
 413         EXCEPTION_GUARD_START_CAPI
 414
 415         if (alias == nullptr || cert.raw_cert == nullptr || cert.cert_size == 0)
 416                 return CKMC_ERROR_INVALID_PARAMETER;
 417
 418         auto mgr = CKM::Manager::create();
 419         return to_ckmc_error(mgr->saveCertificate(CKM::Alias(alias),
 420                                                  _toCkmCertificate(&cert),
 421                                                  _toCkmPolicy(policy)));
 422
 423         EXCEPTION_GUARD_END
 424 }
 425
 426 KEY_MANAGER_CAPI
 427 int ckmc_remove_cert(const char *alias)
 428 {
 429         LogWarning("DEPRECATION WARNING: " << __func__ << "() is deprecated and will be "
 430                            "removed from next release. Use ckmc_remove_alias() instead.");
 431         return ckmc_remove_alias(alias);
 432 }
 433
 434 KEY_MANAGER_CAPI
 435 int ckmc_get_cert(const char *alias, const char *password, ckmc_cert_s **cert)
 436 {
 437         EXCEPTION_GUARD_START_CAPI
 438
 439         CKM::CertificateShPtr ckmCert;
 440         int ret;
 441
 442         if (alias == nullptr || cert == nullptr)
 443                 return CKMC_ERROR_INVALID_PARAMETER;
 444
 445         auto mgr = CKM::Manager::create();
 446
 447         if ((ret = mgr->getCertificate(alias, _tostring(password),
 448                                                                    ckmCert)) != CKM_API_SUCCESS)
 449                 return to_ckmc_error(ret);
 450
 451         if (!ckmCert || ckmCert->empty())
 452                 return CKMC_ERROR_BAD_RESPONSE;
 453
 454         auto buffer = ckmCert->getDER();
 455         return ckmc_cert_new(buffer.data(), buffer.size(), CKMC_FORM_DER, cert);
 456
 457         EXCEPTION_GUARD_END
 458 }
 459
 460 KEY_MANAGER_CAPI
 461 int ckmc_get_cert_alias_list(ckmc_alias_list_s **alias_list)
 462 {
 463         EXCEPTION_GUARD_START_CAPI
 464
 465         if (alias_list == nullptr)
 466                 return CKMC_ERROR_INVALID_PARAMETER;
 467
 468         CKM::AliasVector aliasVector;
 469         int ret;
 470         auto mgr = CKM::Manager::create();
 471
 472         if ((ret = mgr->getCertificateAliasVector(aliasVector)) != CKM_API_SUCCESS)
 473                 return to_ckmc_error(ret);
 474
 475         ckmc_alias_list_s *start = nullptr;
 476         ckmc_alias_list_s *plist = nullptr;
 477
 478         for (const auto &it : aliasVector) {
 479                 char *alias = strndup(it.c_str(), it.size());
 480
 481                 ret = ckmc_alias_list_add(plist, alias, &plist);
 482
 483                 if (ret != CKMC_ERROR_NONE) {
 484                         free(alias);
 485                         ckmc_alias_list_all_free(start);
 486                         return ret;
 487                 }
 488
 489                 if (start == nullptr)
 490                         start = plist;
 491         }
 492
 493         if (plist == nullptr) // if the alias_list size is zero
 494                 return CKMC_ERROR_DB_ALIAS_UNKNOWN;
 495
 496         *alias_list = start;
 497
 498         return CKMC_ERROR_NONE;
 499
 500         EXCEPTION_GUARD_END
 501 }
 502
 503 KEY_MANAGER_CAPI
 504 int ckmc_get_cert_alias_info_list(ckmc_alias_info_list_s **alias_info_list)
 505 {
 506         return ckmc_generic_get_alias_info_list_helper(alias_info_list,
 507                         &CKM::Manager::getCertificateAliasPwdVector);
 508 }
 509
 510 KEY_MANAGER_CAPI
 511 int ckmc_save_pkcs12(const char *alias, const ckmc_pkcs12_s *ppkcs,
 512                                          const ckmc_policy_s key_policy, const ckmc_policy_s cert_policy)
 513 {
 514         EXCEPTION_GUARD_START_CAPI
 515
 516         if (alias == nullptr || ppkcs == nullptr)
 517                 return CKMC_ERROR_INVALID_PARAMETER;
 518
 519         CKM::PKCS12ShPtr pkcs12(new CKM::PKCS12Impl(
 520                                                                 _toCkmKey(ppkcs->priv_key),
 521                                                                 _toCkmCertificate(ppkcs->cert),
 522                                                                 _toCkmCertificateVector(ppkcs->ca_chain)));
 523
 524         auto mgr = CKM::Manager::create();
 525         return to_ckmc_error(mgr->savePKCS12(
 526                                                          CKM::Alias(alias),
 527                                                          pkcs12,
 528                                                          _toCkmPolicy(key_policy),
 529                                                          _toCkmPolicy(cert_policy)));
 530
 531         EXCEPTION_GUARD_END
 532 }
 533
 534 KEY_MANAGER_CAPI
 535 int ckmc_get_pkcs12(const char *alias, const char *key_password,
 536                                         const char *cert_password, ckmc_pkcs12_s **pkcs12)
 537 {
 538         EXCEPTION_GUARD_START_CAPI
 539
 540         if (!alias || !pkcs12)
 541                 return CKMC_ERROR_INVALID_PARAMETER;
 542
 543         int ret;
 544         CKM::PKCS12ShPtr pkcs;
 545         auto mgr = CKM::Manager::create();
 546         std::unique_ptr<ckmc_key_s, decltype(&ckmc_key_free)> private_key_uptr(
 547                         NULL, ckmc_key_free);
 548         std::unique_ptr<ckmc_cert_s, decltype(&ckmc_cert_free)> cert_uptr(
 549                         NULL, ckmc_cert_free);
 550
 551         if ((ret = mgr->getPKCS12(alias, _tostring(key_password),
 552                                                           _tostring(cert_password), pkcs)) != CKM_API_SUCCESS)
 553                 return to_ckmc_error(ret);
 554
 555         if (!pkcs)
 556                 return CKMC_ERROR_BAD_RESPONSE;
 557
 558         auto pkcsKey = pkcs->getKey();
 559
 560         if (pkcsKey) {
 561                 if (pkcsKey->empty())
 562                         return CKMC_ERROR_BAD_RESPONSE;
 563
 564                 ckmc_key_s *private_key = nullptr;
 565                 auto buffer = pkcsKey->getDER();
 566                 ckmc_key_type_e keyType = static_cast<ckmc_key_type_e>(pkcsKey->getType());
 567                 ret = ckmc_key_new(buffer.data(), buffer.size(), keyType, nullptr,
 568                                                    &private_key);
 569
 570                 if (ret != CKMC_ERROR_NONE)
 571                         return ret;
 572
 573                 private_key_uptr.reset(private_key);
 574         }
 575
 576         auto pkcsCert = pkcs->getCertificate();
 577
 578         if (pkcsCert) {
 579                 if (pkcsCert->empty())
 580                         return CKMC_ERROR_BAD_RESPONSE;
 581
 582                 ckmc_cert_s *cert = nullptr;
 583                 CKM::RawBuffer buffer = pkcsCert->getDER();
 584                 ret = ckmc_cert_new(buffer.data(), buffer.size(), CKMC_FORM_DER, &cert);
 585
 586                 if (ret != CKMC_ERROR_NONE) {
 587                         return ret;
 588                 }
 589                 cert_uptr.reset(cert);
 590         }
 591
 592         std::unique_ptr<ckmc_cert_list_s, decltype(&ckmc_cert_list_free)> cert_list_uptr(
 593                         _toNewCkmCertList(pkcs->getCaCertificateShPtrVector()),
 594                         ckmc_cert_list_free);
 595
 596         ret = ckmc_pkcs12_new(private_key_uptr.get(), cert_uptr.get(), cert_list_uptr.get(), pkcs12);
 597         if (ret == CKMC_ERROR_NONE) {
 598                 private_key_uptr.release();
 599                 cert_uptr.release();
 600                 cert_list_uptr.release();
 601         }
 602
 603         return ret;
 604
 605         EXCEPTION_GUARD_END
 606 }
 607
 608
 609 KEY_MANAGER_CAPI
 610 int ckmc_save_data(const char *alias, ckmc_raw_buffer_s data,
 611                                    const ckmc_policy_s policy)
 612 {
 613         EXCEPTION_GUARD_START_CAPI
 614
 615         if (alias == nullptr || data.data == nullptr || data.size == 0)
 616                 return CKMC_ERROR_INVALID_PARAMETER;
 617
 618         auto mgr = CKM::Manager::create();
 619         return to_ckmc_error(mgr->saveData(
 620                                                          CKM::Alias(alias),
 621                                                          CKM::RawBuffer(data.data, data.data + data.size),
 622                                                          _toCkmPolicy(policy)));
 623
 624         EXCEPTION_GUARD_END
 625 }
 626
 627 KEY_MANAGER_CAPI
 628 int ckmc_remove_data(const char *alias)
 629 {
 630         LogWarning("DEPRECATION WARNING: " << __func__ << "() is deprecated and will be "
 631                            "removed from next release. Use ckmc_remove_alias() instead.");
 632         return ckmc_remove_alias(alias);
 633 }
 634
 635 KEY_MANAGER_CAPI
 636 int ckmc_get_data(const char *alias, const char *password,
 637                                   ckmc_raw_buffer_s **data)
 638 {
 639         EXCEPTION_GUARD_START_CAPI
 640
 641         if (alias == nullptr || data == nullptr)
 642                 return CKMC_ERROR_INVALID_PARAMETER;
 643
 644         int ret;
 645         CKM::RawBuffer ckmBuff;
 646         auto mgr = CKM::Manager::create();
 647
 648         if ((ret = mgr->getData(alias, _tostring(password),
 649                                                         ckmBuff)) != CKM_API_SUCCESS)
 650                 return to_ckmc_error(ret);
 651
 652         return ckmc_buffer_new(ckmBuff.data(), ckmBuff.size(), data);
 653
 654         EXCEPTION_GUARD_END
 655 }
 656
 657 KEY_MANAGER_CAPI
 658 int ckmc_get_data_alias_list(ckmc_alias_list_s **alias_list)
 659 {
 660         EXCEPTION_GUARD_START_CAPI
 661
 662         if (alias_list == nullptr)
 663                 return CKMC_ERROR_INVALID_PARAMETER;
 664
 665         int ret;
 666         CKM::AliasVector aliasVector;
 667         auto mgr = CKM::Manager::create();
 668
 669         if ((ret = mgr->getDataAliasVector(aliasVector)) != CKM_API_SUCCESS)
 670                 return to_ckmc_error(ret);
 671
 672         ckmc_alias_list_s *start = nullptr;
 673         ckmc_alias_list_s *plist = nullptr;
 674
 675         for (const auto &it : aliasVector) {
 676                 char *alias = strndup(it.c_str(), it.size());
 677
 678                 ret = ckmc_alias_list_add(plist, alias, &plist);
 679
 680                 if (ret != CKMC_ERROR_NONE) {
 681                         free(alias);
 682                         ckmc_alias_list_all_free(start);
 683                         return ret;
 684                 }
 685
 686                 if (start == nullptr)
 687                         start = plist;
 688         }
 689
 690         if (plist == nullptr) // if the alias_list size is zero
 691                 return CKMC_ERROR_DB_ALIAS_UNKNOWN;
 692
 693         *alias_list = start;
 694
 695         return CKMC_ERROR_NONE;
 696
 697         EXCEPTION_GUARD_END
 698 }
 699
 700 KEY_MANAGER_CAPI
 701 int ckmc_get_data_alias_info_list(ckmc_alias_info_list_s **alias_info_list)
 702 {
 703         return ckmc_generic_get_alias_info_list_helper(alias_info_list,
 704                         &CKM::Manager::getDataAliasPwdVector);
 705 }
 706
 707 KEY_MANAGER_CAPI
 708 int ckmc_create_key_pair_rsa(const size_t size,
 709                                                          const char *private_key_alias,
 710                                                          const char *public_key_alias,
 711                                                          const ckmc_policy_s policy_private_key,
 712                                                          const ckmc_policy_s policy_public_key)
 713 {
 714         EXCEPTION_GUARD_START_CAPI
 715
 716         auto mgr = CKM::Manager::create();
 717
 718         if (private_key_alias == nullptr || public_key_alias == nullptr)
 719                 return CKMC_ERROR_INVALID_PARAMETER;
 720
 721         return to_ckmc_error(mgr->createKeyPairRSA(
 722                                                          static_cast<int>(size),
 723                                                          CKM::Alias(private_key_alias),
 724                                                          CKM::Alias(public_key_alias),
 725                                                          _toCkmPolicy(policy_private_key),
 726                                                          _toCkmPolicy(policy_public_key)));
 727
 728         EXCEPTION_GUARD_END
 729 }
 730
 731 KEY_MANAGER_CAPI
 732 int ckmc_create_key_pair_dsa(const size_t size,
 733                                                          const char *private_key_alias,
 734                                                          const char *public_key_alias,
 735                                                          const ckmc_policy_s policy_private_key,
 736                                                          const ckmc_policy_s policy_public_key)
 737 {
 738         EXCEPTION_GUARD_START_CAPI
 739
 740         if (private_key_alias == nullptr || public_key_alias == nullptr)
 741                 return CKMC_ERROR_INVALID_PARAMETER;
 742
 743         auto mgr = CKM::Manager::create();
 744         return to_ckmc_error(mgr->createKeyPairDSA(
 745                                                          static_cast<int>(size),
 746                                                          CKM::Alias(private_key_alias),
 747                                                          CKM::Alias(public_key_alias),
 748                                                          _toCkmPolicy(policy_private_key),
 749                                                          _toCkmPolicy(policy_public_key)));
 750
 751         EXCEPTION_GUARD_END
 752 }
 753
 754 KEY_MANAGER_CAPI
 755 int ckmc_create_key_pair_ecdsa(const ckmc_ec_type_e type,
 756                                                            const char *private_key_alias,
 757                                                            const char *public_key_alias,
 758                                                            const ckmc_policy_s policy_private_key,
 759                                                            const ckmc_policy_s policy_public_key)
 760 {
 761         EXCEPTION_GUARD_START_CAPI
 762
 763         if (private_key_alias == nullptr || public_key_alias == nullptr)
 764                 return CKMC_ERROR_INVALID_PARAMETER;
 765
 766         auto mgr = CKM::Manager::create();
 767         return to_ckmc_error(mgr->createKeyPairECDSA(
 768                                                          static_cast<CKM::ElipticCurve>(static_cast<int>(type)),
 769                                                          CKM::Alias(private_key_alias),
 770                                                          CKM::Alias(public_key_alias),
 771                                                          _toCkmPolicy(policy_private_key),
 772                                                          _toCkmPolicy(policy_public_key)));
 773
 774         EXCEPTION_GUARD_END
 775 }
 776
 777 KEY_MANAGER_CAPI
 778 int ckmc_create_key_aes(size_t size,
 779                                                 const char *key_alias,
 780                                                 ckmc_policy_s key_policy)
 781 {
 782         EXCEPTION_GUARD_START_CAPI
 783
 784         if (key_alias == nullptr)
 785                 return CKMC_ERROR_INVALID_PARAMETER;
 786
 787         auto mgr = CKM::Manager::create();
 788         return to_ckmc_error(mgr->createKeyAES(size, CKM::Alias(key_alias),
 789                                                                                    _toCkmPolicy(key_policy)));
 790
 791         EXCEPTION_GUARD_END
 792 }
 793
 794 KEY_MANAGER_CAPI
 795 int ckmc_create_signature(const char *private_key_alias,
 796                                                   const char *password,
 797                                                   const ckmc_raw_buffer_s message,
 798                                                   const ckmc_hash_algo_e hash,
 799                                                   const ckmc_rsa_padding_algo_e padding,
 800                                                   ckmc_raw_buffer_s **signature)
 801 {
 802         EXCEPTION_GUARD_START_CAPI
 803
 804         if (private_key_alias == nullptr || signature == nullptr)
 805                 return CKMC_ERROR_INVALID_PARAMETER;
 806
 807         int ret;
 808         CKM::RawBuffer ckmSignature;
 809         auto mgr = CKM::Manager::create();
 810
 811         if ((ret = mgr->createSignature(
 812                                    CKM::Alias(private_key_alias),
 813                                    _tostring(password),
 814                                    CKM::RawBuffer(message.data, message.data + message.size),
 815                                    static_cast<CKM::HashAlgorithm>(static_cast<int>(hash)),
 816                                    static_cast<CKM::RSAPaddingAlgorithm>(static_cast<int>(padding)),
 817                                    ckmSignature)) != CKM_API_SUCCESS)
 818                 return to_ckmc_error(ret);
 819
 820         return ckmc_buffer_new(ckmSignature.data(), ckmSignature.size(), signature);
 821
 822         EXCEPTION_GUARD_END
 823 }
 824
 825 KEY_MANAGER_CAPI
 826 int ckmc_verify_signature(const char *public_key_alias,
 827                                                   const char *password,
 828                                                   const ckmc_raw_buffer_s message,
 829                                                   const ckmc_raw_buffer_s signature,
 830                                                   const ckmc_hash_algo_e hash,
 831                                                   const ckmc_rsa_padding_algo_e padding)
 832 {
 833         EXCEPTION_GUARD_START_CAPI
 834
 835         if (public_key_alias == nullptr)
 836                 return CKMC_ERROR_INVALID_PARAMETER;
 837
 838         int ret;
 839         auto mgr = CKM::Manager::create();
 840
 841         if ((ret = mgr->verifySignature(
 842                                    CKM::Alias(public_key_alias),
 843                                    _tostring(password),
 844                                    CKM::RawBuffer(message.data, message.data + message.size),
 845                                    CKM::RawBuffer(signature.data, signature.data + signature.size),
 846                                    static_cast<CKM::HashAlgorithm>(static_cast<int>(hash)),
 847                                    static_cast<CKM::RSAPaddingAlgorithm>(static_cast<int>(padding)))) !=
 848                         CKM_API_SUCCESS)
 849                 return to_ckmc_error(ret);
 850
 851         return CKMC_ERROR_NONE;
 852
 853         EXCEPTION_GUARD_END
 854 }
 855
 856 KEY_MANAGER_CAPI
 857 int ckmc_get_cert_chain(const ckmc_cert_s *cert,
 858                                                 const ckmc_cert_list_s *untrustedcerts, ckmc_cert_list_s **cert_chain_list)
 859 {
 860         EXCEPTION_GUARD_START_CAPI
 861
 862         if (cert == nullptr || cert->raw_cert == nullptr || cert->cert_size == 0 ||
 863                         cert_chain_list == nullptr)
 864                 return CKMC_ERROR_INVALID_PARAMETER;
 865
 866         CKM::CertificateShPtrVector ckmCertChain;
 867         auto mgr = CKM::Manager::create();
 868         int ret = mgr->getCertificateChain(
 869                                   _toCkmCertificate(cert),
 870                                   _toCkmCertificateVector(untrustedcerts),
 871                                   EMPTY_CERT_VECTOR,
 872                                   true,
 873                                   ckmCertChain);
 874
 875         if (ret != CKM_API_SUCCESS)
 876                 return to_ckmc_error(ret);
 877
 878         *cert_chain_list = _toNewCkmCertList(ckmCertChain);
 879
 880         return CKMC_ERROR_NONE;
 881
 882         EXCEPTION_GUARD_END
 883 }
 884
 885 KEY_MANAGER_CAPI
 886 int ckmc_get_cert_chain_with_alias(const ckmc_cert_s *cert,
 887                                                                    const ckmc_alias_list_s *untrustedcerts, ckmc_cert_list_s **cert_chain_list)
 888 {
 889         EXCEPTION_GUARD_START_CAPI
 890
 891         if (cert == nullptr || cert->raw_cert == nullptr || cert->cert_size == 0 ||
 892                         cert_chain_list == nullptr)
 893                 return CKMC_ERROR_INVALID_PARAMETER;
 894
 895         CKM::CertificateShPtrVector ckmCertChain;
 896         auto mgr = CKM::Manager::create();
 897         int ret = mgr->getCertificateChain(_toCkmCertificate(cert),
 898                                                                            _toCkmAliasVector(untrustedcerts),
 899                                                                            EMPTY_ALIAS_VECTOR, true, ckmCertChain);
 900
 901         if (ret != CKM_API_SUCCESS)
 902                 return to_ckmc_error(ret);
 903
 904         *cert_chain_list = _toNewCkmCertList(ckmCertChain);
 905
 906         return CKMC_ERROR_NONE;
 907
 908         EXCEPTION_GUARD_END
 909 }
 910
 911 KEY_MANAGER_CAPI
 912 int ckmc_get_cert_chain_with_trustedcert(const ckmc_cert_s *cert,
 913                 const ckmc_cert_list_s *untrustedcerts,
 914                 const ckmc_cert_list_s *trustedcerts,
 915                 const bool sys_certs,
 916                 ckmc_cert_list_s **ppcert_chain_list)
 917 {
 918         EXCEPTION_GUARD_START_CAPI
 919
 920         if (cert == nullptr || cert->raw_cert == nullptr || cert->cert_size == 0 ||
 921                         ppcert_chain_list == nullptr)
 922                 return CKMC_ERROR_INVALID_PARAMETER;
 923
 924         CKM::CertificateShPtrVector ckmCertChain;
 925         auto mgr = CKM::Manager::create();
 926         int ret = mgr->getCertificateChain(
 927                                   _toCkmCertificate(cert),
 928                                   _toCkmCertificateVector(untrustedcerts),
 929                                   _toCkmCertificateVector(trustedcerts),
 930                                   sys_certs,
 931                                   ckmCertChain);
 932
 933         if (ret != CKM_API_SUCCESS)
 934                 return to_ckmc_error(ret);
 935
 936         *ppcert_chain_list = _toNewCkmCertList(ckmCertChain);
 937
 938         return CKMC_ERROR_NONE;
 939
 940         EXCEPTION_GUARD_END
 941 }
 942
 943 KEY_MANAGER_CAPI
 944 int ckmc_ocsp_check(const ckmc_cert_list_s *pcert_chain_list,
 945                                         ckmc_ocsp_status_e *ocsp_status)
 946 {
 947         EXCEPTION_GUARD_START_CAPI
 948
 949         if (pcert_chain_list == nullptr
 950                         || pcert_chain_list->cert == nullptr
 951                         || pcert_chain_list->cert->raw_cert == nullptr
 952                         || pcert_chain_list->cert->cert_size == 0
 953                         || ocsp_status == nullptr)
 954                 return CKMC_ERROR_INVALID_PARAMETER;
 955
 956         int tmpOcspStatus = -1;
 957         auto mgr = CKM::Manager::create();
 958         int ret = mgr->ocspCheck(_toCkmCertificateVector(pcert_chain_list),
 959                                                          tmpOcspStatus);
 960
 961         *ocsp_status = to_ckmc_ocsp_status(tmpOcspStatus);
 962
 963         return to_ckmc_error(ret);
 964
 965         EXCEPTION_GUARD_END
 966 }
 967
 968 KEY_MANAGER_CAPI
 969 int ckmc_allow_access(const char *alias, const char *accessor,
 970                                           ckmc_access_right_e granted)
 971 {
 972         EXCEPTION_GUARD_START_CAPI
 973
 974         LogWarning("DEPRECATION WARNING: " << __func__ << "() is deprecated and will be "
 975                            "removed from next release. Use ckmc_set_permission() instead.");
 976
 977         int permissionMask;
 978         int ret = access_to_permission_mask(granted, permissionMask);
 979
 980         if (ret != CKMC_ERROR_NONE)
 981                 return ret;
 982
 983         return ckmc_set_permission(alias, accessor, permissionMask);
 984
 985         EXCEPTION_GUARD_END
 986 }
 987
 988 KEY_MANAGER_CAPI
 989 int ckmc_set_permission(const char *alias, const char *accessor,
 990                                                 int permissions)
 991 {
 992         EXCEPTION_GUARD_START_CAPI
 993
 994         if (!alias || !accessor)
 995                 return CKMC_ERROR_INVALID_PARAMETER;
 996
 997         auto mgr = CKM::Manager::create();
 998         return to_ckmc_error(mgr->setPermission(alias, accessor, permissions));
 999
1000         EXCEPTION_GUARD_END
1001 }
1002
1003 KEY_MANAGER_CAPI
1004 int ckmc_deny_access(const char *alias, const char *accessor)
1005 {
1006         EXCEPTION_GUARD_START_CAPI
1007
1008         LogWarning("DEPRECATION WARNING: " << __func__ << "() is deprecated and will be "
1009                            "removed from next release. Use ckmc_set_permission() instead.");
1010
1011         if (!alias || !accessor)
1012                 return CKMC_ERROR_INVALID_PARAMETER;
1013
1014         auto mgr = CKM::Manager::create();
1015         return to_ckmc_error(mgr->setPermission(alias, accessor,
1016                                                                                         CKM::Permission::NONE));
1017
1018         EXCEPTION_GUARD_END
1019 }
1020
1021 KEY_MANAGER_CAPI
1022 int ckmc_remove_alias(const char *alias)
1023 {
1024         EXCEPTION_GUARD_START_CAPI
1025
1026         if (!alias)
1027                 return CKMC_ERROR_INVALID_PARAMETER;
1028
1029         auto mgr = CKM::Manager::create();
1030         return to_ckmc_error(mgr->removeAlias(alias));
1031
1032         EXCEPTION_GUARD_END
1033 }
1034
1035 KEY_MANAGER_CAPI
1036 int ckmc_encrypt_data(ckmc_param_list_h params,
1037                                           const char *key_alias,
1038                                           const char *password,
1039                                           const ckmc_raw_buffer_s decrypted,
1040                                           ckmc_raw_buffer_s **ppencrypted)
1041 {
1042         EXCEPTION_GUARD_START_CAPI
1043
1044         return _cryptoOperation(&CKM::Manager::encrypt,
1045                                                         params,
1046                                                         key_alias,
1047                                                         password,
1048                                                         decrypted,
1049                                                         ppencrypted);
1050
1051         EXCEPTION_GUARD_END
1052 }
1053
1054 KEY_MANAGER_CAPI
1055 int ckmc_decrypt_data(ckmc_param_list_h params,
1056                                           const char *key_alias,
1057                                           const char *password,
1058                                           const ckmc_raw_buffer_s encrypted,
1059                                           ckmc_raw_buffer_s **ppdecrypted)
1060 {
1061         EXCEPTION_GUARD_START_CAPI
1062
1063         return _cryptoOperation(&CKM::Manager::decrypt,
1064                                                         params,
1065                                                         key_alias,
1066                                                         password,
1067                                                         encrypted,
1068                                                         ppdecrypted);
1069
1070         EXCEPTION_GUARD_END
1071 }