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::KeyShPtr _toCkmKey(const ckmc_key_s *key)
  43 {
  44     if(key)
  45     {
  46         CKM::RawBuffer buffer(key->raw_key, key->raw_key + key->key_size);
  47         return CKM::Key::create(buffer, _tostring(key->password));
  48     }
  49     return CKM::KeyShPtr();
  50 }
  51
  52 CKM::CertificateShPtr _toCkmCertificate(const ckmc_cert_s *cert)
  53 {
  54     if(cert)
  55     {
  56         CKM::RawBuffer buffer(cert->raw_cert, cert->raw_cert + cert->cert_size);
  57         CKM::DataFormat dataFormat = static_cast<CKM::DataFormat>(static_cast<int>(cert->data_format));
  58         return CKM::Certificate::create(buffer, dataFormat);
  59     }
  60     return CKM::CertificateShPtr();
  61 }
  62
  63 ckmc_cert_list_s *_toNewCkmCertList(const CKM::CertificateShPtrVector &certVector)
  64 {
  65     int ret;
  66     ckmc_cert_list_s *start = NULL;
  67     ckmc_cert_list_s *plist = NULL;
  68     CKM::CertificateShPtrVector::const_iterator it;
  69     for(it = certVector.begin(); it != certVector.end(); it++) {
  70         CKM::RawBuffer rawBuffer = (*it)->getDER();
  71         unsigned char *rawCert = static_cast<unsigned char *>(malloc(rawBuffer.size()));
  72         memcpy(rawCert, rawBuffer.data(), rawBuffer.size());
  73         ckmc_cert_s *pcert;
  74         ret = ckmc_cert_new(rawCert, rawBuffer.size(), CKMC_FORM_DER, &pcert);
  75         free(rawCert);
  76         if(pcert == NULL) {
  77             ckmc_cert_list_all_free(start);
  78             return NULL;
  79         }
  80         if(plist == NULL) {
  81             ret = ckmc_cert_list_new(pcert, &plist);
  82             start = plist; // save the pointer of the first element
  83         }else {
  84             ret = ckmc_cert_list_add(plist, pcert, &plist);
  85         }
  86         if(ret != CKMC_ERROR_NONE) {
  87             ckmc_cert_list_all_free(start);
  88             return NULL;
  89         }
  90     }
  91     return start;
  92 }
  93
  94 }
  95
  96
  97 KEY_MANAGER_CAPI
  98 int ckmc_save_key(const char *alias, const ckmc_key_s key, const ckmc_policy_s policy)
  99 {
 100     CKM::ManagerShPtr mgr = CKM::Manager::create();
 101
 102     if(alias == NULL) {
 103         return CKMC_ERROR_INVALID_PARAMETER;
 104     }
 105     CKM::Alias ckmAlias(alias);
 106
 107     if(key.raw_key == NULL || key.key_size <= 0) {
 108             return CKMC_ERROR_INVALID_PARAMETER;
 109     }
 110     CKM::RawBuffer buffer(key.raw_key, key.raw_key + key.key_size);
 111     CKM::KeyShPtr ckmKey = CKM::Key::create(buffer, _tostring(key.password));
 112
 113     if(ckmKey.get() == NULL) {
 114         return CKMC_ERROR_INVALID_FORMAT;
 115     }
 116
 117     CKM::Policy storePolicy(_tostring(policy.password), policy.extractable);
 118
 119     int ret =  mgr->saveKey(ckmAlias, ckmKey, storePolicy);
 120     return to_ckmc_error(ret);
 121 }
 122
 123
 124 KEY_MANAGER_CAPI
 125 int ckmc_remove_key(const char *alias)
 126 {
 127     return ckmc_remove_alias(alias);
 128 }
 129
 130 KEY_MANAGER_CAPI
 131 int ckmc_get_key(const char *alias, const char *password, ckmc_key_s **key)
 132 {
 133     int ret;
 134     CKM::KeyShPtr ckmKey;
 135
 136     if(alias == NULL || key == NULL) {
 137         return CKMC_ERROR_INVALID_PARAMETER;
 138     }
 139
 140     CKM::ManagerShPtr mgr = CKM::Manager::create();
 141     if( (ret = mgr->getKey(alias, _tostring(password), ckmKey)) != CKM_API_SUCCESS) {
 142         return to_ckmc_error(ret);
 143     }
 144
 145     unsigned char *rawKey = reinterpret_cast<unsigned char*>(ckmKey->getDER().data());
 146     ckmc_key_type_e keyType = static_cast<ckmc_key_type_e>(static_cast<int>(ckmKey->getType()));
 147
 148     ret = ckmc_key_new( rawKey, ckmKey->getDER().size(), keyType, NULL, key);
 149
 150     return to_ckmc_error(ret);
 151 }
 152
 153 KEY_MANAGER_CAPI
 154 int ckmc_get_key_alias_list(ckmc_alias_list_s** alias_list)
 155 {
 156     int ret;
 157
 158     if (alias_list == NULL) {
 159         return CKMC_ERROR_INVALID_PARAMETER;
 160     }
 161
 162     CKM::AliasVector aliasVector;
 163     CKM::ManagerShPtr mgr = CKM::Manager::create();
 164
 165     if ((ret = mgr->getKeyAliasVector(aliasVector)) != CKM_API_SUCCESS) {
 166         return to_ckmc_error(ret);
 167     }
 168
 169     ckmc_alias_list_s *plist = NULL;
 170
 171     for (const auto it : aliasVector) {
 172         char *alias = strndup(it.c_str(), it.size());
 173
 174         if (plist == NULL) { // first
 175             ret = ckmc_alias_list_new(alias, &plist);
 176             *alias_list = plist; // save the pointer of the first element
 177         } else {
 178             ret = ckmc_alias_list_add(plist, alias, &plist);
 179         }
 180
 181         if (ret != CKMC_ERROR_NONE) {
 182             free(alias);
 183             ckmc_alias_list_all_free(*alias_list);
 184             return ret;
 185         }
 186     }
 187
 188     if(plist == NULL) { // if the alias_list size is zero
 189         return CKMC_ERROR_DB_ALIAS_UNKNOWN;
 190     }
 191
 192     return CKMC_ERROR_NONE;
 193 }
 194
 195 KEY_MANAGER_CAPI
 196 int ckmc_save_cert(const char *alias, const ckmc_cert_s cert, const ckmc_policy_s policy)
 197 {
 198     if(alias == NULL) {
 199         return CKMC_ERROR_INVALID_PARAMETER;
 200     }
 201     CKM::Alias ckmAlias(alias);
 202
 203     if(cert.raw_cert == NULL || cert.cert_size <= 0) {
 204             return CKMC_ERROR_INVALID_PARAMETER;
 205     }
 206     CKM::CertificateShPtr ckmCert = _toCkmCertificate(&cert);
 207     if(ckmCert.get() == NULL) {
 208         return CKMC_ERROR_INVALID_FORMAT;
 209     }
 210
 211     CKM::Policy storePolicy(_tostring(policy.password), policy.extractable);
 212
 213     CKM::ManagerShPtr mgr = CKM::Manager::create();
 214     int ret = mgr->saveCertificate(ckmAlias, ckmCert, storePolicy);
 215
 216     return to_ckmc_error(ret);
 217 }
 218
 219 KEY_MANAGER_CAPI
 220 int ckmc_remove_cert(const char *alias)
 221 {
 222     return ckmc_remove_alias(alias);
 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_pkcs12(const char *alias, const ckmc_pkcs12_s *ppkcs, const ckmc_policy_s key_policy, const ckmc_policy_s cert_policy)
 290 {
 291     CKM::KeyShPtr private_key;
 292     CKM::CertificateShPtr cert;
 293     CKM::CertificateShPtrVector ca_cert_list;
 294
 295     if(alias==NULL || ppkcs==NULL) {
 296         return CKMC_ERROR_INVALID_PARAMETER;
 297     }
 298     CKM::Alias ckmAlias(alias);
 299
 300     private_key = _toCkmKey(ppkcs->priv_key);
 301     cert = _toCkmCertificate(ppkcs->cert);
 302     ckmc_cert_list_s *current = NULL;
 303     ckmc_cert_list_s *next = const_cast<ckmc_cert_list_s *>(ppkcs->ca_chain);
 304     do {
 305         current = next;
 306         next = current->next;
 307
 308         if(current->cert == NULL){
 309             continue;
 310         }
 311
 312         CKM::CertificateShPtr tmpCkmCert = _toCkmCertificate(current->cert);
 313         ca_cert_list.push_back(tmpCkmCert);
 314     }while(next != NULL);
 315
 316     CKM::Policy keyPolicy(_tostring(key_policy.password), key_policy.extractable);
 317     CKM::Policy certPolicy(_tostring(cert_policy.password), cert_policy.extractable);
 318
 319     CKM::PKCS12ShPtr pkcs12(new CKM::PKCS12Impl(private_key, cert, ca_cert_list));
 320
 321     CKM::ManagerShPtr mgr = CKM::Manager::create();
 322     int ret = mgr->savePKCS12(ckmAlias, pkcs12, keyPolicy, certPolicy);
 323
 324     return to_ckmc_error(ret);
 325 }
 326
 327 KEY_MANAGER_CAPI
 328 int ckmc_remove_pkcs12(const char *alias)
 329 {
 330     return ckmc_remove_alias(alias);
 331 }
 332
 333 KEY_MANAGER_CAPI
 334 int ckmc_get_pkcs12(const char *alias, ckmc_pkcs12_s **pkcs12)
 335 {
 336     int ret;
 337     CKM::PKCS12ShPtr ShPkcs12;
 338     CKM::PKCS12 *pkcs12Ptr = NULL;
 339     ckmc_key_s *private_key = NULL;
 340     ckmc_cert_s *cert = NULL;
 341     ckmc_cert_list_s *ca_cert_list = 0;
 342
 343     if(alias == NULL || pkcs12 == NULL) {
 344         return CKMC_ERROR_INVALID_PARAMETER;
 345     }
 346
 347     CKM::ManagerShPtr mgr = CKM::Manager::create();
 348     if( (ret = mgr->getPKCS12(alias, ShPkcs12)) != CKM_API_SUCCESS) {
 349         return to_ckmc_error(ret);
 350     }
 351
 352     pkcs12Ptr = ShPkcs12.get();
 353     if(!pkcs12Ptr)
 354         return CKMC_ERROR_BAD_RESPONSE;
 355
 356     if(pkcs12Ptr->getKey())
 357     {
 358         CKM::KeyShPtr helper = pkcs12Ptr->getKey();
 359
 360         unsigned char *rawKey = reinterpret_cast<unsigned char*>(helper->getDER().data());
 361         ckmc_key_type_e keyType = static_cast<ckmc_key_type_e>(static_cast<int>(helper->getType()));
 362         ret = ckmc_key_new(rawKey, helper->getDER().size(), keyType, NULL, &private_key);
 363         if(ret != CKMC_ERROR_NONE)
 364             return ret;
 365     }
 366
 367     if(pkcs12Ptr->getCertificate())
 368     {
 369         CKM::CertificateShPtr helper = pkcs12Ptr->getCertificate();
 370
 371         unsigned char *rawCert = reinterpret_cast<unsigned char*>(helper->getDER().data());
 372         ret = ckmc_cert_new(rawCert, helper->getDER().size(), CKMC_FORM_DER, &cert);
 373         if(ret != CKMC_ERROR_NONE) {
 374             ckmc_key_free(private_key);
 375             return ret;
 376         }
 377     }
 378
 379     ca_cert_list = _toNewCkmCertList(pkcs12Ptr->getCaCertificateShPtrVector());
 380
 381     ret = ckmc_pkcs12_new(private_key, cert, ca_cert_list, pkcs12);
 382     if(ret != CKMC_ERROR_NONE)
 383     {
 384         ckmc_key_free(private_key);
 385         ckmc_cert_free(cert);
 386         ckmc_cert_list_free(ca_cert_list);
 387     }
 388     return ret;
 389 }
 390
 391 KEY_MANAGER_CAPI
 392 int ckmc_save_data(const char *alias, ckmc_raw_buffer_s data, const ckmc_policy_s policy)
 393 {
 394     if(alias == NULL) {
 395         return CKMC_ERROR_INVALID_PARAMETER;
 396     }
 397     CKM::Alias ckmAlias(alias);
 398
 399     if(data.data == NULL || data.size <= 0) {
 400             return CKMC_ERROR_INVALID_PARAMETER;
 401     }
 402     CKM::RawBuffer buffer(data.data, data.data + data.size);
 403
 404     CKM::Policy storePolicy(_tostring(policy.password), policy.extractable);
 405
 406     CKM::ManagerShPtr mgr = CKM::Manager::create();
 407     int ret = mgr->saveData(ckmAlias, buffer, storePolicy);
 408
 409     return to_ckmc_error(ret);
 410 }
 411
 412 KEY_MANAGER_CAPI
 413 int ckmc_remove_data(const char *alias)
 414 {
 415     return ckmc_remove_alias(alias);
 416 }
 417
 418 KEY_MANAGER_CAPI
 419 int ckmc_get_data(const char *alias, const char *password, ckmc_raw_buffer_s **data)
 420 {
 421     CKM::RawBuffer ckmBuff;
 422     int ret;
 423
 424     if(alias == NULL || data == NULL) {
 425         return CKMC_ERROR_INVALID_PARAMETER;
 426     }
 427
 428     CKM::ManagerShPtr mgr = CKM::Manager::create();
 429     if( (ret = mgr->getData(alias, _tostring(password), ckmBuff)) != CKM_API_SUCCESS) {
 430         return to_ckmc_error(ret);
 431     }
 432
 433     unsigned char *rawBuff = reinterpret_cast<unsigned char*>(ckmBuff.data());
 434     ret = ckmc_buffer_new(rawBuff, ckmBuff.size(), data);
 435
 436     return ret;
 437 }
 438
 439 KEY_MANAGER_CAPI
 440 int ckmc_get_data_alias_list(ckmc_alias_list_s** alias_list){
 441     int ret;
 442
 443     if(alias_list == NULL) {
 444         return CKMC_ERROR_INVALID_PARAMETER;
 445     }
 446
 447     *alias_list = NULL;
 448
 449     CKM::AliasVector aliasVector;
 450     CKM::ManagerShPtr mgr = CKM::Manager::create();
 451     if( (ret = mgr->getDataAliasVector(aliasVector)) != CKM_API_SUCCESS) {
 452         return to_ckmc_error(ret);
 453     }
 454
 455     ckmc_alias_list_s *plist = NULL;
 456
 457     for (const auto it : aliasVector) {
 458         char *alias = strndup(it.c_str(), it.size());
 459
 460         if (plist == NULL) { // first
 461             ret = ckmc_alias_list_new(alias, &plist);
 462             *alias_list = plist; // save the pointer of the first element
 463         } else {
 464             ret = ckmc_alias_list_add(plist, alias, &plist);
 465         }
 466
 467         if (ret != CKMC_ERROR_NONE) {
 468             free(alias);
 469             ckmc_alias_list_all_free(*alias_list);
 470             return ret;
 471         }
 472     }
 473
 474     if(plist == NULL) { // if the alias_list size is zero
 475         return CKMC_ERROR_DB_ALIAS_UNKNOWN;
 476     }
 477
 478     return CKMC_ERROR_NONE;
 479 }
 480
 481 KEY_MANAGER_CAPI
 482 int ckmc_create_key_pair_rsa(const size_t size,
 483                             const char *private_key_alias,
 484                             const char *public_key_alias,
 485                             const ckmc_policy_s policy_private_key,
 486                             const ckmc_policy_s policy_public_key)
 487 {
 488     int ret;
 489     CKM::ManagerShPtr mgr = CKM::Manager::create();
 490
 491     if(private_key_alias == NULL || public_key_alias == NULL) {
 492         return CKMC_ERROR_INVALID_PARAMETER;
 493     }
 494
 495     CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 496     CKM::Alias ckmPublicKeyAlias(public_key_alias);
 497     CKM::Policy ckmPrivateKeyPolicy(_tostring(policy_private_key.password), policy_private_key.extractable);
 498     CKM::Policy ckmPublicKeyPolicy(_tostring(policy_public_key.password), policy_public_key.extractable);
 499
 500     ret = mgr->createKeyPairRSA(static_cast<int>(size), ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy);
 501     return to_ckmc_error(ret);
 502 }
 503
 504 KEY_MANAGER_CAPI
 505 int ckmc_create_key_pair_dsa(const size_t size,
 506                             const char *private_key_alias,
 507                             const char *public_key_alias,
 508                             const ckmc_policy_s policy_private_key,
 509                             const ckmc_policy_s policy_public_key)
 510 {
 511     int ret;
 512     CKM::ManagerShPtr mgr = CKM::Manager::create();
 513
 514     if(private_key_alias == NULL || public_key_alias == NULL) {
 515         return CKMC_ERROR_INVALID_PARAMETER;
 516     }
 517
 518     CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 519     CKM::Alias ckmPublicKeyAlias(public_key_alias);
 520     CKM::Policy ckmPrivateKeyPolicy(_tostring(policy_private_key.password), policy_private_key.extractable);
 521     CKM::Policy ckmPublicKeyPolicy(_tostring(policy_public_key.password), policy_public_key.extractable);
 522
 523     ret = mgr->createKeyPairDSA(static_cast<int>(size), ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy);
 524     return to_ckmc_error(ret);
 525 }
 526
 527 KEY_MANAGER_CAPI
 528 int ckmc_create_key_pair_ecdsa(const ckmc_ec_type_e type,
 529                             const char *private_key_alias,
 530                             const char *public_key_alias,
 531                             const ckmc_policy_s policy_private_key,
 532                             const ckmc_policy_s policy_public_key)
 533 {
 534     CKM::ManagerShPtr mgr = CKM::Manager::create();
 535
 536     if(private_key_alias == NULL || public_key_alias == NULL) {
 537         return CKMC_ERROR_INVALID_PARAMETER;
 538     }
 539
 540     CKM::ElipticCurve ckmType = static_cast<CKM::ElipticCurve>(static_cast<int>(type));
 541     CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 542     CKM::Alias ckmPublicKeyAlias(public_key_alias);
 543     CKM::Policy ckmPrivateKeyPolicy(_tostring(policy_private_key.password), policy_private_key.extractable);
 544     CKM::Policy ckmPublicKeyPolicy(_tostring(policy_public_key.password), policy_public_key.extractable);
 545
 546     int ret = mgr->createKeyPairECDSA(ckmType, ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy);
 547     return to_ckmc_error(ret);
 548 }
 549
 550 KEY_MANAGER_CAPI
 551 int ckmc_create_signature(const char *private_key_alias,
 552                             const char *password,
 553                             const ckmc_raw_buffer_s message,
 554                             const ckmc_hash_algo_e hash,
 555                             const ckmc_rsa_padding_algo_e padding,
 556                             ckmc_raw_buffer_s **signature)
 557 {
 558     int ret;
 559     CKM::ManagerShPtr mgr = CKM::Manager::create();
 560     CKM::RawBuffer ckmSignature;
 561
 562     if(private_key_alias == NULL || signature == NULL) {
 563         return CKMC_ERROR_INVALID_PARAMETER;
 564     }
 565
 566     CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 567     CKM::RawBuffer ckmMessage(message.data, message.data + message.size);
 568     CKM::HashAlgorithm ckmHashAlgo = static_cast<CKM::HashAlgorithm>(static_cast<int>(hash));
 569     CKM::RSAPaddingAlgorithm ckmPadding = static_cast<CKM::RSAPaddingAlgorithm>(static_cast<int>(padding));
 570
 571     if( (ret = mgr->createSignature(
 572             ckmPrivakeKeyAlias,
 573             _tostring(password),
 574             ckmMessage,
 575             ckmHashAlgo,
 576             ckmPadding,
 577             ckmSignature)) != CKM_API_SUCCESS) {
 578         return to_ckmc_error(ret);
 579     }
 580
 581     unsigned char *rawBuff = reinterpret_cast<unsigned char*>(ckmSignature.data());
 582     ret = ckmc_buffer_new( rawBuff, ckmSignature.size(), signature);
 583
 584     return ret;
 585 }
 586
 587 KEY_MANAGER_CAPI
 588 int ckmc_verify_signature(const char *public_key_alias,
 589                             const char *password,
 590                             const ckmc_raw_buffer_s message,
 591                             const ckmc_raw_buffer_s signature,
 592                             const ckmc_hash_algo_e hash,
 593                             const ckmc_rsa_padding_algo_e padding)
 594 {
 595     int ret;
 596     CKM::ManagerShPtr mgr = CKM::Manager::create();
 597
 598     if(public_key_alias == NULL) {
 599         return CKMC_ERROR_INVALID_PARAMETER;
 600     }
 601
 602     CKM::Alias ckmPublicKeyAlias(public_key_alias);
 603     CKM::RawBuffer ckmMessage(message.data, message.data + message.size);
 604     CKM::RawBuffer ckmSignature(signature.data, signature.data + signature.size);
 605     CKM::HashAlgorithm ckmHashAlgo = static_cast<CKM::HashAlgorithm>(static_cast<int>(hash));
 606     CKM::RSAPaddingAlgorithm ckmPadding = static_cast<CKM::RSAPaddingAlgorithm>(static_cast<int>(padding));
 607
 608     if( (ret = mgr->verifySignature(
 609             ckmPublicKeyAlias,
 610             _tostring(password),
 611             ckmMessage,
 612             ckmSignature,
 613             ckmHashAlgo,
 614             ckmPadding)) != CKM_API_SUCCESS) {
 615         return to_ckmc_error(ret);
 616     }
 617
 618     return CKMC_ERROR_NONE;
 619 }
 620
 621 KEY_MANAGER_CAPI
 622 int ckmc_get_cert_chain(const ckmc_cert_s *cert, const ckmc_cert_list_s *untrustedcerts, ckmc_cert_list_s **cert_chain_list)
 623 {
 624     int ret;
 625     CKM::ManagerShPtr mgr = CKM::Manager::create();
 626     CKM::CertificateShPtrVector ckmCertChain;
 627
 628     if(cert == NULL || cert->raw_cert == NULL || cert->cert_size <= 0 || cert_chain_list == NULL) {
 629         return CKMC_ERROR_INVALID_PARAMETER;
 630     }
 631
 632     CKM::CertificateShPtr ckmCert = _toCkmCertificate(cert);
 633
 634     CKM::CertificateShPtrVector ckmUntrustedCerts;
 635     if(untrustedcerts != NULL) {
 636         ckmc_cert_list_s *current = NULL;
 637         ckmc_cert_list_s *next = const_cast<ckmc_cert_list_s *>(untrustedcerts);
 638         do {
 639             current = next;
 640             next = current->next;
 641
 642             if(current->cert == NULL){
 643                 continue;
 644             }
 645
 646             CKM::CertificateShPtr tmpCkmCert = _toCkmCertificate(current->cert);
 647             ckmUntrustedCerts.push_back(tmpCkmCert);
 648         }while(next != NULL);
 649     }
 650
 651     ret = mgr->getCertificateChain(ckmCert, ckmUntrustedCerts, ckmCertChain);
 652     if( ret != CKM_API_SUCCESS) {
 653         return to_ckmc_error(ret);
 654     }
 655
 656     *cert_chain_list = _toNewCkmCertList(ckmCertChain);
 657
 658     return CKMC_ERROR_NONE;
 659 }
 660
 661 KEY_MANAGER_CAPI
 662 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)
 663 {
 664     int ret;
 665     CKM::ManagerShPtr mgr = CKM::Manager::create();
 666     CKM::CertificateShPtrVector ckmCertChain;
 667
 668
 669     if(cert == NULL || cert->raw_cert == NULL || cert->cert_size <= 0 || cert_chain_list == NULL) {
 670         return CKMC_ERROR_INVALID_PARAMETER;
 671     }
 672
 673     CKM::CertificateShPtr ckmCert = _toCkmCertificate(cert);
 674     if(ckmCert.get() == NULL) {
 675         return CKMC_ERROR_INVALID_FORMAT;
 676     }
 677
 678     CKM::AliasVector ckmUntrustedAliases;
 679     if(untrustedcerts != NULL) {
 680         ckmc_alias_list_s *current = NULL;
 681         ckmc_alias_list_s *next = const_cast<ckmc_alias_list_s *>(untrustedcerts);
 682         do {
 683             current = next;
 684             next = current->next;
 685
 686             if(current->alias == NULL){
 687                 return CKMC_ERROR_INVALID_PARAMETER;
 688             }
 689             CKM::Alias ckmAlias(current->alias);
 690             ckmUntrustedAliases.push_back(ckmAlias);
 691         }while(next != NULL);
 692     }
 693
 694     if( (ret = mgr->getCertificateChain(ckmCert, ckmUntrustedAliases, ckmCertChain)) != CKM_API_SUCCESS) {
 695         return to_ckmc_error(ret);
 696     }
 697
 698     *cert_chain_list = _toNewCkmCertList(ckmCertChain);
 699
 700     return CKMC_ERROR_NONE;
 701 }
 702
 703 KEY_MANAGER_CAPI
 704 int ckmc_ocsp_check(const ckmc_cert_list_s *pcert_chain_list, ckmc_ocsp_status_e *ocsp_status)
 705 {
 706     if (pcert_chain_list == NULL
 707         || pcert_chain_list->cert == NULL
 708         || pcert_chain_list->cert->raw_cert == NULL
 709         || pcert_chain_list->cert->cert_size <= 0
 710         || ocsp_status == NULL) {
 711         return CKMC_ERROR_INVALID_PARAMETER;
 712     }
 713
 714     int ret = CKMC_ERROR_UNKNOWN;
 715     int tmpOcspStatus = -1;
 716     CKM::ManagerShPtr mgr = CKM::Manager::create();
 717     CKM::CertificateShPtrVector ckmCertChain;
 718     const ckmc_cert_list_s *current = NULL;
 719     const ckmc_cert_list_s *next = pcert_chain_list;
 720
 721     do {
 722         current = next;
 723         next = current->next;
 724         if (current->cert == NULL)
 725             continue;
 726
 727         ckmCertChain.push_back(_toCkmCertificate(current->cert));
 728     } while (next != NULL);
 729
 730     ret = mgr->ocspCheck(ckmCertChain, tmpOcspStatus);
 731     *ocsp_status = to_ckmc_ocsp_status(tmpOcspStatus);
 732     return to_ckmc_error(ret);
 733 }
 734
 735 KEY_MANAGER_CAPI
 736 int ckmc_allow_access(const char *alias, const char *accessor, ckmc_access_right_e granted)
 737 {
 738     return ckmc_set_permission(alias, accessor, static_cast<int>(granted));
 739 }
 740
 741 KEY_MANAGER_CAPI
 742 int ckmc_set_permission(const char *alias, const char *accessor, int permissions)
 743 {
 744     if (!alias || !accessor)
 745         return CKMC_ERROR_INVALID_PARAMETER;
 746
 747     CKM::ManagerShPtr mgr = CKM::Manager::create();
 748     return to_ckmc_error(mgr->setPermission(alias, accessor, permissions));
 749 }
 750
 751 KEY_MANAGER_CAPI
 752 int ckmc_deny_access(const char *alias, const char *accessor)
 753 {
 754     if (!alias || !accessor)
 755         return CKMC_ERROR_INVALID_PARAMETER;
 756
 757     CKM::ManagerShPtr mgr = CKM::Manager::create();
 758     return to_ckmc_error(mgr->setPermission(alias, accessor, CKM::Permission::NONE));
 759 }
 760
 761 KEY_MANAGER_CAPI
 762 int ckmc_remove_alias(const char *alias)
 763 {
 764     if(!alias)
 765         return CKMC_ERROR_INVALID_PARAMETER;
 766
 767     CKM::ManagerShPtr mgr = CKM::Manager::create();
 768     int ret =  mgr->removeAlias(alias);
 769     return to_ckmc_error(ret);
 770 }