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