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 CKM::Password _tostring(const char *str)
  36 {
  37     if(str == NULL)
  38         return CKM::Password();
  39     return CKM::Password(str);
  40 }
  41
  42 CKM::CertificateShPtr _toCkmCertificate(const ckmc_cert_s *cert)
  43 {
  44     CKM::RawBuffer buffer(cert->raw_cert, cert->raw_cert + cert->cert_size);
  45     CKM::DataFormat dataFormat = static_cast<CKM::DataFormat>(static_cast<int>(cert->data_format));
  46     return CKM::Certificate::create(buffer, dataFormat);
  47 }
  48
  49 ckmc_cert_list_s *_toNewCkmCertList(CKM::CertificateShPtrVector &certVector)
  50 {
  51     int ret;
  52     ckmc_cert_list_s *start = NULL;
  53     ckmc_cert_list_s *plist = NULL;
  54     CKM::CertificateShPtrVector::iterator it;
  55     for(it = certVector.begin(); it != certVector.end(); it++) {
  56         CKM::RawBuffer rawBuffer = (*it)->getDER();
  57         unsigned char *rawCert = static_cast<unsigned char *>(malloc(rawBuffer.size()));
  58         memcpy(rawCert, rawBuffer.data(), rawBuffer.size());
  59         ckmc_cert_s *pcert;
  60         ret = ckmc_cert_new(rawCert, rawBuffer.size(), CKMC_FORM_DER, &pcert);
  61         free(rawCert);
  62         if(pcert == NULL) {
  63             ckmc_cert_list_all_free(start);
  64             return NULL;
  65         }
  66         if(plist == NULL) {
  67             ret = ckmc_cert_list_new(pcert, &plist);
  68             start = plist; // save the pointer of the first element
  69         }else {
  70             ret = ckmc_cert_list_add(plist, pcert, &plist);
  71         }
  72         if(ret != CKMC_ERROR_NONE) {
  73             ckmc_cert_list_all_free(start);
  74             return NULL;
  75         }
  76     }
  77     return start;
  78 }
  79
  80 }
  81
  82
  83 KEY_MANAGER_CAPI
  84 int ckmc_save_key(const char *alias, const ckmc_key_s key, const ckmc_policy_s policy)
  85 {
  86     CKM::ManagerShPtr mgr = CKM::Manager::create();
  87
  88     if(alias == NULL) {
  89         return CKMC_ERROR_INVALID_PARAMETER;
  90     }
  91     CKM::Alias ckmAlias(alias);
  92
  93     if(key.raw_key == NULL || key.key_size <= 0) {
  94             return CKMC_ERROR_INVALID_PARAMETER;
  95     }
  96     CKM::RawBuffer buffer(key.raw_key, key.raw_key + key.key_size);
  97     CKM::KeyShPtr ckmKey = CKM::Key::create(buffer, _tostring(key.password));
  98
  99     if(ckmKey.get() == NULL) {
 100         return CKMC_ERROR_INVALID_FORMAT;
 101     }
 102
 103     CKM::Policy storePolicy(_tostring(policy.password), policy.extractable);
 104
 105     int ret =  mgr->saveKey(ckmAlias, ckmKey, storePolicy);
 106     return to_ckmc_error(ret);
 107 }
 108
 109
 110 KEY_MANAGER_CAPI
 111 int ckmc_remove_key(const char *alias)
 112 {
 113     CKM::ManagerShPtr mgr = CKM::Manager::create();
 114
 115     if(alias == NULL) {
 116         return CKMC_ERROR_INVALID_PARAMETER;
 117     }
 118
 119     int ret =  mgr->removeKey(alias);
 120     return to_ckmc_error(ret);
 121 }
 122
 123 KEY_MANAGER_CAPI
 124 int ckmc_get_key(const char *alias, const char *password, ckmc_key_s **key)
 125 {
 126     int ret;
 127     CKM::KeyShPtr ckmKey;
 128
 129     if(alias == NULL || key == NULL) {
 130         return CKMC_ERROR_INVALID_PARAMETER;
 131     }
 132
 133     CKM::ManagerShPtr mgr = CKM::Manager::create();
 134     if( (ret = mgr->getKey(alias, _tostring(password), ckmKey)) != CKM_API_SUCCESS) {
 135         return to_ckmc_error(ret);
 136     }
 137
 138     unsigned char *rawKey = reinterpret_cast<unsigned char*>(ckmKey->getDER().data());
 139     ckmc_key_type_e keyType = static_cast<ckmc_key_type_e>(static_cast<int>(ckmKey->getType()));
 140
 141     ret = ckmc_key_new( rawKey, ckmKey->getDER().size(), keyType, NULL, key);
 142
 143     return to_ckmc_error(ret);
 144 }
 145
 146 KEY_MANAGER_CAPI
 147 int ckmc_get_key_alias_list(ckmc_alias_list_s** alias_list)
 148 {
 149     int ret;
 150
 151     if (alias_list == NULL) {
 152         return CKMC_ERROR_INVALID_PARAMETER;
 153     }
 154
 155     CKM::AliasVector aliasVector;
 156     CKM::ManagerShPtr mgr = CKM::Manager::create();
 157
 158     if ((ret = mgr->getKeyAliasVector(aliasVector)) != CKM_API_SUCCESS) {
 159         return to_ckmc_error(ret);
 160     }
 161
 162     ckmc_alias_list_s *plist = NULL;
 163
 164     for (const auto it : aliasVector) {
 165         char *alias = strndup(it.c_str(), it.size());
 166
 167         if (plist == NULL) { // first
 168             ret = ckmc_alias_list_new(alias, &plist);
 169             *alias_list = plist; // save the pointer of the first element
 170         } else {
 171             ret = ckmc_alias_list_add(plist, alias, &plist);
 172         }
 173
 174         if (ret != CKMC_ERROR_NONE) {
 175             free(alias);
 176             ckmc_alias_list_all_free(*alias_list);
 177             return ret;
 178         }
 179     }
 180
 181     if(plist == NULL) { // if the alias_list size is zero
 182         return CKMC_ERROR_DB_ALIAS_UNKNOWN;
 183     }
 184
 185     return CKMC_ERROR_NONE;
 186 }
 187
 188 KEY_MANAGER_CAPI
 189 int ckmc_save_cert(const char *alias, const ckmc_cert_s cert, const ckmc_policy_s policy)
 190 {
 191     if(alias == NULL) {
 192         return CKMC_ERROR_INVALID_PARAMETER;
 193     }
 194     CKM::Alias ckmAlias(alias);
 195
 196     if(cert.raw_cert == NULL || cert.cert_size <= 0) {
 197             return CKMC_ERROR_INVALID_PARAMETER;
 198     }
 199     CKM::CertificateShPtr ckmCert = _toCkmCertificate(&cert);
 200     if(ckmCert.get() == NULL) {
 201         return CKMC_ERROR_INVALID_FORMAT;
 202     }
 203
 204     CKM::Policy storePolicy(_tostring(policy.password), policy.extractable);
 205
 206     CKM::ManagerShPtr mgr = CKM::Manager::create();
 207     int ret = mgr->saveCertificate(ckmAlias, ckmCert, storePolicy);
 208
 209     return to_ckmc_error(ret);
 210 }
 211
 212 KEY_MANAGER_CAPI
 213 int ckmc_remove_cert(const char *alias)
 214 {
 215     if(alias == NULL) {
 216         return CKMC_ERROR_INVALID_PARAMETER;
 217     }
 218
 219     CKM::ManagerShPtr mgr = CKM::Manager::create();
 220     int ret = mgr->removeCertificate(alias);
 221
 222     return to_ckmc_error(ret);
 223 }
 224
 225 KEY_MANAGER_CAPI
 226 int ckmc_get_cert(const char *alias, const char *password, ckmc_cert_s **cert)
 227 {
 228     CKM::CertificateShPtr ckmCert;
 229     int ret;
 230
 231     if(alias == NULL || cert == NULL) {
 232         return CKMC_ERROR_INVALID_PARAMETER;
 233     }
 234
 235     CKM::ManagerShPtr mgr = CKM::Manager::create();
 236     if( (ret = mgr->getCertificate(alias, _tostring(password), ckmCert)) != CKM_API_SUCCESS) {
 237         return to_ckmc_error(ret);
 238     }
 239
 240     unsigned char *rawCert = reinterpret_cast<unsigned char*>(ckmCert->getDER().data());
 241     ret = ckmc_cert_new( rawCert, ckmCert->getDER().size(), CKMC_FORM_DER, cert);
 242
 243     return ret;
 244 }
 245
 246 KEY_MANAGER_CAPI
 247 int ckmc_get_cert_alias_list(ckmc_alias_list_s** alias_list) {
 248     int ret;
 249
 250     if (alias_list == NULL) {
 251         return CKMC_ERROR_INVALID_PARAMETER;
 252     }
 253
 254     *alias_list = NULL;
 255
 256     CKM::AliasVector aliasVector;
 257     CKM::ManagerShPtr mgr = CKM::Manager::create();
 258     if ((ret = mgr->getCertificateAliasVector(aliasVector)) != CKM_API_SUCCESS) {
 259         return to_ckmc_error(ret);
 260     }
 261
 262     ckmc_alias_list_s *plist = NULL;
 263
 264     for (const auto it : aliasVector) {
 265         char *alias = strndup(it.c_str(), it.size());
 266
 267         if (plist == NULL) { // first
 268             ret  = ckmc_alias_list_new(alias, &plist);
 269             *alias_list = plist; // save the pointer of the first element
 270         } else {
 271             ret = ckmc_alias_list_add(plist, alias, &plist);
 272         }
 273
 274         if (ret != CKMC_ERROR_NONE) {
 275             free(alias);
 276             ckmc_alias_list_all_free(*alias_list);
 277             return ret;
 278         }
 279     }
 280
 281     if(plist == NULL) { // if the alias_list size is zero
 282         return CKMC_ERROR_DB_ALIAS_UNKNOWN;
 283     }
 284
 285     return CKMC_ERROR_NONE;
 286 }
 287
 288 KEY_MANAGER_CAPI
 289 int ckmc_save_data(const char *alias, ckmc_raw_buffer_s data, const ckmc_policy_s policy)
 290 {
 291     if(alias == NULL) {
 292         return CKMC_ERROR_INVALID_PARAMETER;
 293     }
 294     CKM::Alias ckmAlias(alias);
 295
 296     if(data.data == NULL || data.size <= 0) {
 297             return CKMC_ERROR_INVALID_PARAMETER;
 298     }
 299     CKM::RawBuffer buffer(data.data, data.data + data.size);
 300
 301     CKM::Policy storePolicy(_tostring(policy.password), policy.extractable);
 302
 303     CKM::ManagerShPtr mgr = CKM::Manager::create();
 304     int ret = mgr->saveData(ckmAlias, buffer, storePolicy);
 305
 306     return to_ckmc_error(ret);
 307 }
 308
 309 KEY_MANAGER_CAPI
 310 int ckmc_remove_data(const char *alias)
 311 {
 312     if(alias == NULL) {
 313         return CKMC_ERROR_INVALID_PARAMETER;
 314     }
 315
 316     CKM::ManagerShPtr mgr = CKM::Manager::create();
 317     int ret = mgr->removeData(alias);
 318     return to_ckmc_error(ret);
 319 }
 320
 321 KEY_MANAGER_CAPI
 322 int ckmc_get_data(const char *alias, const char *password, ckmc_raw_buffer_s **data)
 323 {
 324     CKM::RawBuffer ckmBuff;
 325     int ret;
 326
 327     if(alias == NULL || data == NULL) {
 328         return CKMC_ERROR_INVALID_PARAMETER;
 329     }
 330
 331     CKM::ManagerShPtr mgr = CKM::Manager::create();
 332     if( (ret = mgr->getData(alias, _tostring(password), ckmBuff)) != CKM_API_SUCCESS) {
 333         return to_ckmc_error(ret);
 334     }
 335
 336     unsigned char *rawBuff = reinterpret_cast<unsigned char*>(ckmBuff.data());
 337     ret = ckmc_buffer_new(rawBuff, ckmBuff.size(), data);
 338
 339     return ret;
 340 }
 341
 342 KEY_MANAGER_CAPI
 343 int ckmc_get_data_alias_list(ckmc_alias_list_s** alias_list){
 344     int ret;
 345
 346     if(alias_list == NULL) {
 347         return CKMC_ERROR_INVALID_PARAMETER;
 348     }
 349
 350     *alias_list = NULL;
 351
 352     CKM::AliasVector aliasVector;
 353     CKM::ManagerShPtr mgr = CKM::Manager::create();
 354     if( (ret = mgr->getDataAliasVector(aliasVector)) != CKM_API_SUCCESS) {
 355         return to_ckmc_error(ret);
 356     }
 357
 358     ckmc_alias_list_s *plist = NULL;
 359
 360     for (const auto it : aliasVector) {
 361         char *alias = strndup(it.c_str(), it.size());
 362
 363         if (plist == NULL) { // first
 364             ret = ckmc_alias_list_new(alias, &plist);
 365             *alias_list = plist; // save the pointer of the first element
 366         } else {
 367             ret = ckmc_alias_list_add(plist, alias, &plist);
 368         }
 369
 370         if (ret != CKMC_ERROR_NONE) {
 371             free(alias);
 372             ckmc_alias_list_all_free(*alias_list);
 373             return ret;
 374         }
 375     }
 376
 377     if(plist == NULL) { // if the alias_list size is zero
 378         return CKMC_ERROR_DB_ALIAS_UNKNOWN;
 379     }
 380
 381     return CKMC_ERROR_NONE;
 382 }
 383
 384 KEY_MANAGER_CAPI
 385 int ckmc_create_key_pair_rsa(const size_t size,
 386                             const char *private_key_alias,
 387                             const char *public_key_alias,
 388                             const ckmc_policy_s policy_private_key,
 389                             const ckmc_policy_s policy_public_key)
 390 {
 391     int ret;
 392     CKM::ManagerShPtr mgr = CKM::Manager::create();
 393
 394     if(private_key_alias == NULL || public_key_alias == NULL) {
 395         return CKMC_ERROR_INVALID_PARAMETER;
 396     }
 397
 398     CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 399     CKM::Alias ckmPublicKeyAlias(public_key_alias);
 400     CKM::Policy ckmPrivateKeyPolicy(_tostring(policy_private_key.password), policy_private_key.extractable);
 401     CKM::Policy ckmPublicKeyPolicy(_tostring(policy_public_key.password), policy_public_key.extractable);
 402
 403     ret = mgr->createKeyPairRSA(static_cast<int>(size), ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy);
 404     return to_ckmc_error(ret);
 405 }
 406
 407 KEY_MANAGER_CAPI
 408 int ckmc_create_key_pair_dsa(const size_t size,
 409                             const char *private_key_alias,
 410                             const char *public_key_alias,
 411                             const ckmc_policy_s policy_private_key,
 412                             const ckmc_policy_s policy_public_key)
 413 {
 414     int ret;
 415     CKM::ManagerShPtr mgr = CKM::Manager::create();
 416
 417     if(private_key_alias == NULL || public_key_alias == NULL) {
 418         return CKMC_ERROR_INVALID_PARAMETER;
 419     }
 420
 421     CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 422     CKM::Alias ckmPublicKeyAlias(public_key_alias);
 423     CKM::Policy ckmPrivateKeyPolicy(_tostring(policy_private_key.password), policy_private_key.extractable);
 424     CKM::Policy ckmPublicKeyPolicy(_tostring(policy_public_key.password), policy_public_key.extractable);
 425
 426     ret = mgr->createKeyPairDSA(static_cast<int>(size), ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy);
 427     return to_ckmc_error(ret);
 428 }
 429
 430 KEY_MANAGER_CAPI
 431 int ckmc_create_key_pair_ecdsa(const ckmc_ec_type_e type,
 432                             const char *private_key_alias,
 433                             const char *public_key_alias,
 434                             const ckmc_policy_s policy_private_key,
 435                             const ckmc_policy_s policy_public_key)
 436 {
 437     CKM::ManagerShPtr mgr = CKM::Manager::create();
 438
 439     if(private_key_alias == NULL || public_key_alias == NULL) {
 440         return CKMC_ERROR_INVALID_PARAMETER;
 441     }
 442
 443     CKM::ElipticCurve ckmType = static_cast<CKM::ElipticCurve>(static_cast<int>(type));
 444     CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 445     CKM::Alias ckmPublicKeyAlias(public_key_alias);
 446     CKM::Policy ckmPrivateKeyPolicy(_tostring(policy_private_key.password), policy_private_key.extractable);
 447     CKM::Policy ckmPublicKeyPolicy(_tostring(policy_public_key.password), policy_public_key.extractable);
 448
 449     int ret = mgr->createKeyPairECDSA(ckmType, ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy);
 450     return to_ckmc_error(ret);
 451 }
 452
 453 KEY_MANAGER_CAPI
 454 int ckmc_create_signature(const char *private_key_alias,
 455                             const char *password,
 456                             const ckmc_raw_buffer_s message,
 457                             const ckmc_hash_algo_e hash,
 458                             const ckmc_rsa_padding_algo_e padding,
 459                             ckmc_raw_buffer_s **signature)
 460 {
 461     int ret;
 462     CKM::ManagerShPtr mgr = CKM::Manager::create();
 463     CKM::RawBuffer ckmSignature;
 464
 465     if(private_key_alias == NULL || signature == NULL) {
 466         return CKMC_ERROR_INVALID_PARAMETER;
 467     }
 468
 469     CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 470     CKM::RawBuffer ckmMessage(message.data, message.data + message.size);
 471     CKM::HashAlgorithm ckmHashAlgo = static_cast<CKM::HashAlgorithm>(static_cast<int>(hash));
 472     CKM::RSAPaddingAlgorithm ckmPadding = static_cast<CKM::RSAPaddingAlgorithm>(static_cast<int>(padding));
 473
 474     if( (ret = mgr->createSignature(
 475             ckmPrivakeKeyAlias,
 476             _tostring(password),
 477             ckmMessage,
 478             ckmHashAlgo,
 479             ckmPadding,
 480             ckmSignature)) != CKM_API_SUCCESS) {
 481         return to_ckmc_error(ret);
 482     }
 483
 484     unsigned char *rawBuff = reinterpret_cast<unsigned char*>(ckmSignature.data());
 485     ret = ckmc_buffer_new( rawBuff, ckmSignature.size(), signature);
 486
 487     return ret;
 488 }
 489
 490 KEY_MANAGER_CAPI
 491 int ckmc_verify_signature(const char *public_key_alias,
 492                             const char *password,
 493                             const ckmc_raw_buffer_s message,
 494                             const ckmc_raw_buffer_s signature,
 495                             const ckmc_hash_algo_e hash,
 496                             const ckmc_rsa_padding_algo_e padding)
 497 {
 498     int ret;
 499     CKM::ManagerShPtr mgr = CKM::Manager::create();
 500
 501     if(public_key_alias == NULL) {
 502         return CKMC_ERROR_INVALID_PARAMETER;
 503     }
 504
 505     CKM::Alias ckmPublicKeyAlias(public_key_alias);
 506     CKM::RawBuffer ckmMessage(message.data, message.data + message.size);
 507     CKM::RawBuffer ckmSignature(signature.data, signature.data + signature.size);
 508     CKM::HashAlgorithm ckmHashAlgo = static_cast<CKM::HashAlgorithm>(static_cast<int>(hash));
 509     CKM::RSAPaddingAlgorithm ckmPadding = static_cast<CKM::RSAPaddingAlgorithm>(static_cast<int>(padding));
 510
 511     if( (ret = mgr->verifySignature(
 512             ckmPublicKeyAlias,
 513             _tostring(password),
 514             ckmMessage,
 515             ckmSignature,
 516             ckmHashAlgo,
 517             ckmPadding)) != CKM_API_SUCCESS) {
 518         return to_ckmc_error(ret);
 519     }
 520
 521     return CKMC_ERROR_NONE;
 522 }
 523
 524 KEY_MANAGER_CAPI
 525 int ckmc_get_cert_chain(const ckmc_cert_s *cert, const ckmc_cert_list_s *untrustedcerts, ckmc_cert_list_s **cert_chain_list)
 526 {
 527     int ret;
 528     CKM::ManagerShPtr mgr = CKM::Manager::create();
 529     CKM::CertificateShPtrVector ckmCertChain;
 530
 531     if(cert == NULL || cert->raw_cert == NULL || cert->cert_size <= 0 || cert_chain_list == NULL) {
 532         return CKMC_ERROR_INVALID_PARAMETER;
 533     }
 534
 535     CKM::CertificateShPtr ckmCert = _toCkmCertificate(cert);
 536
 537     CKM::CertificateShPtrVector ckmUntrustedCerts;
 538     if(untrustedcerts != NULL) {
 539         ckmc_cert_list_s *current = NULL;
 540         ckmc_cert_list_s *next = const_cast<ckmc_cert_list_s *>(untrustedcerts);
 541         do {
 542             current = next;
 543             next = current->next;
 544
 545             if(current->cert == NULL){
 546                 continue;
 547             }
 548
 549             CKM::CertificateShPtr tmpCkmCert = _toCkmCertificate(current->cert);
 550             ckmUntrustedCerts.push_back(tmpCkmCert);
 551         }while(next != NULL);
 552     }
 553
 554     ret = mgr->getCertificateChain(ckmCert, ckmUntrustedCerts, ckmCertChain);
 555     if( ret != CKM_API_SUCCESS) {
 556         return to_ckmc_error(ret);
 557     }
 558
 559     *cert_chain_list = _toNewCkmCertList(ckmCertChain);
 560
 561     return CKMC_ERROR_NONE;
 562 }
 563
 564 KEY_MANAGER_CAPI
 565 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)
 566 {
 567     int ret;
 568     CKM::ManagerShPtr mgr = CKM::Manager::create();
 569     CKM::CertificateShPtrVector ckmCertChain;
 570
 571
 572     if(cert == NULL || cert->raw_cert == NULL || cert->cert_size <= 0 || cert_chain_list == NULL) {
 573         return CKMC_ERROR_INVALID_PARAMETER;
 574     }
 575
 576     CKM::CertificateShPtr ckmCert = _toCkmCertificate(cert);
 577     if(ckmCert.get() == NULL) {
 578         return CKMC_ERROR_INVALID_FORMAT;
 579     }
 580
 581     CKM::AliasVector ckmUntrustedAliases;
 582     if(untrustedcerts != NULL) {
 583         ckmc_alias_list_s *current = NULL;
 584         ckmc_alias_list_s *next = const_cast<ckmc_alias_list_s *>(untrustedcerts);
 585         do {
 586             current = next;
 587             next = current->next;
 588
 589             if(current->alias == NULL){
 590                 return CKMC_ERROR_INVALID_PARAMETER;
 591             }
 592             CKM::Alias ckmAlias(current->alias);
 593             ckmUntrustedAliases.push_back(ckmAlias);
 594         }while(next != NULL);
 595     }
 596
 597     if( (ret = mgr->getCertificateChain(ckmCert, ckmUntrustedAliases, ckmCertChain)) != CKM_API_SUCCESS) {
 598         return to_ckmc_error(ret);
 599     }
 600
 601     *cert_chain_list = _toNewCkmCertList(ckmCertChain);
 602
 603     return CKMC_ERROR_NONE;
 604 }
 605
 606 KEY_MANAGER_CAPI
 607 int ckmc_allow_access(const char *alias, const char *accessor, ckmc_access_right_e granted)
 608 {
 609     if (!alias || !accessor)
 610         return CKMC_ERROR_INVALID_PARAMETER;
 611
 612     CKM::ManagerShPtr mgr = CKM::Manager::create();
 613
 614     CKM::AccessRight ar = static_cast<CKM::AccessRight>(static_cast<int>(granted));
 615     return to_ckmc_error(mgr->allowAccess(alias, accessor, ar));
 616 }
 617
 618 KEY_MANAGER_CAPI
 619 int ckmc_deny_access(const char *alias, const char *accessor)
 620 {
 621     if (!alias || !accessor)
 622         return CKMC_ERROR_INVALID_PARAMETER;
 623
 624     CKM::ManagerShPtr mgr = CKM::Manager::create();
 625
 626     return to_ckmc_error(mgr->denyAccess(alias, accessor));
 627 }