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 }
 121
 122
 123 KEY_MANAGER_CAPI
 124 int ckmc_save_key(const char *alias, const ckmc_key_s key, const ckmc_policy_s policy)
 125 {
 126     CKM::ManagerShPtr mgr = CKM::Manager::create();
 127
 128     if(alias == NULL) {
 129         return CKMC_ERROR_INVALID_PARAMETER;
 130     }
 131     CKM::Alias ckmAlias(alias);
 132
 133     if(key.raw_key == NULL || key.key_size <= 0) {
 134             return CKMC_ERROR_INVALID_PARAMETER;
 135     }
 136     CKM::RawBuffer buffer(key.raw_key, key.raw_key + key.key_size);
 137     CKM::KeyShPtr ckmKey = CKM::Key::create(buffer, _tostring(key.password));
 138
 139     if(ckmKey.get() == NULL) {
 140         return CKMC_ERROR_INVALID_FORMAT;
 141     }
 142
 143     CKM::Policy storePolicy(_tostring(policy.password), policy.extractable);
 144
 145     int ret =  mgr->saveKey(ckmAlias, ckmKey, storePolicy);
 146     return to_ckmc_error(ret);
 147 }
 148
 149
 150 KEY_MANAGER_CAPI
 151 int ckmc_remove_key(const char *alias)
 152 {
 153     return ckmc_remove_alias(alias);
 154 }
 155
 156 KEY_MANAGER_CAPI
 157 int ckmc_get_key(const char *alias, const char *password, ckmc_key_s **key)
 158 {
 159     int ret;
 160     CKM::KeyShPtr ckmKey;
 161
 162     if(alias == NULL || key == NULL) {
 163         return CKMC_ERROR_INVALID_PARAMETER;
 164     }
 165
 166     CKM::ManagerShPtr mgr = CKM::Manager::create();
 167     if( (ret = mgr->getKey(alias, _tostring(password), ckmKey)) != CKM_API_SUCCESS) {
 168         return to_ckmc_error(ret);
 169     }
 170
 171     CKM::RawBuffer buffer = ckmKey->getDER();
 172     ckmc_key_type_e keyType = static_cast<ckmc_key_type_e>(static_cast<int>(ckmKey->getType()));
 173
 174     ret = ckmc_key_new( buffer.data(), buffer.size(), keyType, NULL, key);
 175
 176     return to_ckmc_error(ret);
 177 }
 178
 179 KEY_MANAGER_CAPI
 180 int ckmc_get_key_alias_list(ckmc_alias_list_s** alias_list)
 181 {
 182     int ret;
 183
 184     if (alias_list == NULL) {
 185         return CKMC_ERROR_INVALID_PARAMETER;
 186     }
 187
 188     CKM::AliasVector aliasVector;
 189     CKM::ManagerShPtr mgr = CKM::Manager::create();
 190
 191     if ((ret = mgr->getKeyAliasVector(aliasVector)) != CKM_API_SUCCESS) {
 192         return to_ckmc_error(ret);
 193     }
 194
 195     ckmc_alias_list_s *plist = NULL;
 196
 197     for (const auto it : aliasVector) {
 198         char *alias = strndup(it.c_str(), it.size());
 199
 200         if (plist == NULL) { // first
 201             ret = ckmc_alias_list_new(alias, &plist);
 202             *alias_list = plist; // save the pointer of the first element
 203         } else {
 204             ret = ckmc_alias_list_add(plist, alias, &plist);
 205         }
 206
 207         if (ret != CKMC_ERROR_NONE) {
 208             free(alias);
 209             ckmc_alias_list_all_free(*alias_list);
 210             return ret;
 211         }
 212     }
 213
 214     if(plist == NULL) { // if the alias_list size is zero
 215         return CKMC_ERROR_DB_ALIAS_UNKNOWN;
 216     }
 217
 218     return CKMC_ERROR_NONE;
 219 }
 220
 221 KEY_MANAGER_CAPI
 222 int ckmc_save_cert(const char *alias, const ckmc_cert_s cert, const ckmc_policy_s policy)
 223 {
 224     if(alias == NULL) {
 225         return CKMC_ERROR_INVALID_PARAMETER;
 226     }
 227     CKM::Alias ckmAlias(alias);
 228
 229     if(cert.raw_cert == NULL || cert.cert_size <= 0) {
 230             return CKMC_ERROR_INVALID_PARAMETER;
 231     }
 232     CKM::CertificateShPtr ckmCert = _toCkmCertificate(&cert);
 233     if(ckmCert.get() == NULL) {
 234         return CKMC_ERROR_INVALID_FORMAT;
 235     }
 236
 237     CKM::Policy storePolicy(_tostring(policy.password), policy.extractable);
 238
 239     CKM::ManagerShPtr mgr = CKM::Manager::create();
 240     int ret = mgr->saveCertificate(ckmAlias, ckmCert, storePolicy);
 241
 242     return to_ckmc_error(ret);
 243 }
 244
 245 KEY_MANAGER_CAPI
 246 int ckmc_remove_cert(const char *alias)
 247 {
 248     return ckmc_remove_alias(alias);
 249 }
 250
 251 KEY_MANAGER_CAPI
 252 int ckmc_get_cert(const char *alias, const char *password, ckmc_cert_s **cert)
 253 {
 254     CKM::CertificateShPtr ckmCert;
 255     int ret;
 256
 257     if(alias == NULL || cert == NULL) {
 258         return CKMC_ERROR_INVALID_PARAMETER;
 259     }
 260
 261     CKM::ManagerShPtr mgr = CKM::Manager::create();
 262     if( (ret = mgr->getCertificate(alias, _tostring(password), ckmCert)) != CKM_API_SUCCESS) {
 263         return to_ckmc_error(ret);
 264     }
 265
 266     CKM::RawBuffer buffer = ckmCert->getDER();
 267     ret = ckmc_cert_new( buffer.data(), buffer.size(), CKMC_FORM_DER, cert);
 268
 269     return ret;
 270 }
 271
 272 KEY_MANAGER_CAPI
 273 int ckmc_get_cert_alias_list(ckmc_alias_list_s** alias_list) {
 274     int ret;
 275
 276     if (alias_list == NULL) {
 277         return CKMC_ERROR_INVALID_PARAMETER;
 278     }
 279
 280     *alias_list = NULL;
 281
 282     CKM::AliasVector aliasVector;
 283     CKM::ManagerShPtr mgr = CKM::Manager::create();
 284     if ((ret = mgr->getCertificateAliasVector(aliasVector)) != CKM_API_SUCCESS) {
 285         return to_ckmc_error(ret);
 286     }
 287
 288     ckmc_alias_list_s *plist = NULL;
 289
 290     for (const auto it : aliasVector) {
 291         char *alias = strndup(it.c_str(), it.size());
 292
 293         if (plist == NULL) { // first
 294             ret  = ckmc_alias_list_new(alias, &plist);
 295             *alias_list = plist; // save the pointer of the first element
 296         } else {
 297             ret = ckmc_alias_list_add(plist, alias, &plist);
 298         }
 299
 300         if (ret != CKMC_ERROR_NONE) {
 301             free(alias);
 302             ckmc_alias_list_all_free(*alias_list);
 303             return ret;
 304         }
 305     }
 306
 307     if(plist == NULL) { // if the alias_list size is zero
 308         return CKMC_ERROR_DB_ALIAS_UNKNOWN;
 309     }
 310
 311     return CKMC_ERROR_NONE;
 312 }
 313
 314 KEY_MANAGER_CAPI
 315 int ckmc_save_pkcs12(const char *alias, const ckmc_pkcs12_s *ppkcs, const ckmc_policy_s key_policy, const ckmc_policy_s cert_policy)
 316 {
 317     CKM::KeyShPtr private_key;
 318     CKM::CertificateShPtr cert;
 319     CKM::CertificateShPtrVector ca_cert_list;
 320
 321     if(alias==NULL || ppkcs==NULL) {
 322         return CKMC_ERROR_INVALID_PARAMETER;
 323     }
 324     CKM::Alias ckmAlias(alias);
 325
 326     private_key = _toCkmKey(ppkcs->priv_key);
 327     cert = _toCkmCertificate(ppkcs->cert);
 328     ckmc_cert_list_s *current = NULL;
 329     ckmc_cert_list_s *next = const_cast<ckmc_cert_list_s *>(ppkcs->ca_chain);
 330     do {
 331         current = next;
 332         next = current->next;
 333
 334         if(current->cert == NULL){
 335             continue;
 336         }
 337
 338         CKM::CertificateShPtr tmpCkmCert = _toCkmCertificate(current->cert);
 339         ca_cert_list.push_back(tmpCkmCert);
 340     }while(next != NULL);
 341
 342     CKM::Policy keyPolicy(_tostring(key_policy.password), key_policy.extractable);
 343     CKM::Policy certPolicy(_tostring(cert_policy.password), cert_policy.extractable);
 344
 345     CKM::PKCS12ShPtr pkcs12(new CKM::PKCS12Impl(private_key, cert, ca_cert_list));
 346
 347     CKM::ManagerShPtr mgr = CKM::Manager::create();
 348     int ret = mgr->savePKCS12(ckmAlias, pkcs12, keyPolicy, certPolicy);
 349
 350     return to_ckmc_error(ret);
 351 }
 352
 353 KEY_MANAGER_CAPI
 354 int ckmc_remove_pkcs12(const char *alias)
 355 {
 356     return ckmc_remove_alias(alias);
 357 }
 358
 359 KEY_MANAGER_CAPI
 360 int ckmc_get_pkcs12(const char *alias, ckmc_pkcs12_s **pkcs12)
 361 {
 362     int ret;
 363     CKM::PKCS12ShPtr ShPkcs12;
 364     CKM::PKCS12 *pkcs12Ptr = NULL;
 365     ckmc_key_s *private_key = NULL;
 366     ckmc_cert_s *cert = NULL;
 367     ckmc_cert_list_s *ca_cert_list = 0;
 368
 369     if(alias == NULL || pkcs12 == NULL) {
 370         return CKMC_ERROR_INVALID_PARAMETER;
 371     }
 372
 373     CKM::ManagerShPtr mgr = CKM::Manager::create();
 374     if( (ret = mgr->getPKCS12(alias, ShPkcs12)) != CKM_API_SUCCESS) {
 375         return to_ckmc_error(ret);
 376     }
 377
 378     pkcs12Ptr = ShPkcs12.get();
 379     if(!pkcs12Ptr)
 380         return CKMC_ERROR_BAD_RESPONSE;
 381
 382     if(pkcs12Ptr->getKey())
 383     {
 384         CKM::KeyShPtr helper = pkcs12Ptr->getKey();
 385
 386         CKM::RawBuffer buffer = helper->getDER();
 387         ckmc_key_type_e keyType = static_cast<ckmc_key_type_e>(static_cast<int>(helper->getType()));
 388         ret = ckmc_key_new(buffer.data(), buffer.size(), keyType, NULL, &private_key);
 389         if(ret != CKMC_ERROR_NONE)
 390             return ret;
 391     }
 392
 393     if(pkcs12Ptr->getCertificate())
 394     {
 395         CKM::CertificateShPtr helper = pkcs12Ptr->getCertificate();
 396
 397         CKM::RawBuffer buffer = helper->getDER();
 398         ret = ckmc_cert_new(buffer.data(), buffer.size(), CKMC_FORM_DER, &cert);
 399         if(ret != CKMC_ERROR_NONE) {
 400             ckmc_key_free(private_key);
 401             return ret;
 402         }
 403     }
 404
 405     ca_cert_list = _toNewCkmCertList(pkcs12Ptr->getCaCertificateShPtrVector());
 406
 407     ret = ckmc_pkcs12_new(private_key, cert, ca_cert_list, pkcs12);
 408     if(ret != CKMC_ERROR_NONE)
 409     {
 410         ckmc_key_free(private_key);
 411         ckmc_cert_free(cert);
 412         ckmc_cert_list_free(ca_cert_list);
 413     }
 414     return ret;
 415 }
 416
 417 KEY_MANAGER_CAPI
 418 int ckmc_save_data(const char *alias, ckmc_raw_buffer_s data, const ckmc_policy_s policy)
 419 {
 420     if(alias == NULL) {
 421         return CKMC_ERROR_INVALID_PARAMETER;
 422     }
 423     CKM::Alias ckmAlias(alias);
 424
 425     if(data.data == NULL || data.size <= 0) {
 426             return CKMC_ERROR_INVALID_PARAMETER;
 427     }
 428     CKM::RawBuffer buffer(data.data, data.data + data.size);
 429
 430     CKM::Policy storePolicy(_tostring(policy.password), policy.extractable);
 431
 432     CKM::ManagerShPtr mgr = CKM::Manager::create();
 433     int ret = mgr->saveData(ckmAlias, buffer, storePolicy);
 434
 435     return to_ckmc_error(ret);
 436 }
 437
 438 KEY_MANAGER_CAPI
 439 int ckmc_remove_data(const char *alias)
 440 {
 441     return ckmc_remove_alias(alias);
 442 }
 443
 444 KEY_MANAGER_CAPI
 445 int ckmc_get_data(const char *alias, const char *password, ckmc_raw_buffer_s **data)
 446 {
 447     CKM::RawBuffer ckmBuff;
 448     int ret;
 449
 450     if(alias == NULL || data == NULL) {
 451         return CKMC_ERROR_INVALID_PARAMETER;
 452     }
 453
 454     CKM::ManagerShPtr mgr = CKM::Manager::create();
 455     if( (ret = mgr->getData(alias, _tostring(password), ckmBuff)) != CKM_API_SUCCESS) {
 456         return to_ckmc_error(ret);
 457     }
 458
 459     ret = ckmc_buffer_new(ckmBuff.data(), ckmBuff.size(), data);
 460
 461     return ret;
 462 }
 463
 464 KEY_MANAGER_CAPI
 465 int ckmc_get_data_alias_list(ckmc_alias_list_s** alias_list){
 466     int ret;
 467
 468     if(alias_list == NULL) {
 469         return CKMC_ERROR_INVALID_PARAMETER;
 470     }
 471
 472     *alias_list = NULL;
 473
 474     CKM::AliasVector aliasVector;
 475     CKM::ManagerShPtr mgr = CKM::Manager::create();
 476     if( (ret = mgr->getDataAliasVector(aliasVector)) != CKM_API_SUCCESS) {
 477         return to_ckmc_error(ret);
 478     }
 479
 480     ckmc_alias_list_s *plist = NULL;
 481
 482     for (const auto it : aliasVector) {
 483         char *alias = strndup(it.c_str(), it.size());
 484
 485         if (plist == NULL) { // first
 486             ret = ckmc_alias_list_new(alias, &plist);
 487             *alias_list = plist; // save the pointer of the first element
 488         } else {
 489             ret = ckmc_alias_list_add(plist, alias, &plist);
 490         }
 491
 492         if (ret != CKMC_ERROR_NONE) {
 493             free(alias);
 494             ckmc_alias_list_all_free(*alias_list);
 495             return ret;
 496         }
 497     }
 498
 499     if(plist == NULL) { // if the alias_list size is zero
 500         return CKMC_ERROR_DB_ALIAS_UNKNOWN;
 501     }
 502
 503     return CKMC_ERROR_NONE;
 504 }
 505
 506 KEY_MANAGER_CAPI
 507 int ckmc_create_key_pair_rsa(const size_t size,
 508                             const char *private_key_alias,
 509                             const char *public_key_alias,
 510                             const ckmc_policy_s policy_private_key,
 511                             const ckmc_policy_s policy_public_key)
 512 {
 513     int ret;
 514     CKM::ManagerShPtr mgr = CKM::Manager::create();
 515
 516     if(private_key_alias == NULL || public_key_alias == NULL) {
 517         return CKMC_ERROR_INVALID_PARAMETER;
 518     }
 519
 520     CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 521     CKM::Alias ckmPublicKeyAlias(public_key_alias);
 522     CKM::Policy ckmPrivateKeyPolicy(_tostring(policy_private_key.password), policy_private_key.extractable);
 523     CKM::Policy ckmPublicKeyPolicy(_tostring(policy_public_key.password), policy_public_key.extractable);
 524
 525     ret = mgr->createKeyPairRSA(static_cast<int>(size), ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy);
 526     return to_ckmc_error(ret);
 527 }
 528
 529 KEY_MANAGER_CAPI
 530 int ckmc_create_key_pair_dsa(const size_t size,
 531                             const char *private_key_alias,
 532                             const char *public_key_alias,
 533                             const ckmc_policy_s policy_private_key,
 534                             const ckmc_policy_s policy_public_key)
 535 {
 536     int ret;
 537     CKM::ManagerShPtr mgr = CKM::Manager::create();
 538
 539     if(private_key_alias == NULL || public_key_alias == NULL) {
 540         return CKMC_ERROR_INVALID_PARAMETER;
 541     }
 542
 543     CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 544     CKM::Alias ckmPublicKeyAlias(public_key_alias);
 545     CKM::Policy ckmPrivateKeyPolicy(_tostring(policy_private_key.password), policy_private_key.extractable);
 546     CKM::Policy ckmPublicKeyPolicy(_tostring(policy_public_key.password), policy_public_key.extractable);
 547
 548     ret = mgr->createKeyPairDSA(static_cast<int>(size), ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy);
 549     return to_ckmc_error(ret);
 550 }
 551
 552 KEY_MANAGER_CAPI
 553 int ckmc_create_key_pair_ecdsa(const ckmc_ec_type_e type,
 554                             const char *private_key_alias,
 555                             const char *public_key_alias,
 556                             const ckmc_policy_s policy_private_key,
 557                             const ckmc_policy_s policy_public_key)
 558 {
 559     CKM::ManagerShPtr mgr = CKM::Manager::create();
 560
 561     if(private_key_alias == NULL || public_key_alias == NULL) {
 562         return CKMC_ERROR_INVALID_PARAMETER;
 563     }
 564
 565     CKM::ElipticCurve ckmType = static_cast<CKM::ElipticCurve>(static_cast<int>(type));
 566     CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 567     CKM::Alias ckmPublicKeyAlias(public_key_alias);
 568     CKM::Policy ckmPrivateKeyPolicy(_tostring(policy_private_key.password), policy_private_key.extractable);
 569     CKM::Policy ckmPublicKeyPolicy(_tostring(policy_public_key.password), policy_public_key.extractable);
 570
 571     int ret = mgr->createKeyPairECDSA(ckmType, ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy);
 572     return to_ckmc_error(ret);
 573 }
 574
 575 KEY_MANAGER_CAPI
 576 int ckmc_create_signature(const char *private_key_alias,
 577                             const char *password,
 578                             const ckmc_raw_buffer_s message,
 579                             const ckmc_hash_algo_e hash,
 580                             const ckmc_rsa_padding_algo_e padding,
 581                             ckmc_raw_buffer_s **signature)
 582 {
 583     int ret;
 584     CKM::ManagerShPtr mgr = CKM::Manager::create();
 585     CKM::RawBuffer ckmSignature;
 586
 587     if(private_key_alias == NULL || signature == NULL) {
 588         return CKMC_ERROR_INVALID_PARAMETER;
 589     }
 590
 591     CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 592     CKM::RawBuffer ckmMessage(message.data, message.data + message.size);
 593     CKM::HashAlgorithm ckmHashAlgo = static_cast<CKM::HashAlgorithm>(static_cast<int>(hash));
 594     CKM::RSAPaddingAlgorithm ckmPadding = static_cast<CKM::RSAPaddingAlgorithm>(static_cast<int>(padding));
 595
 596     if( (ret = mgr->createSignature(
 597             ckmPrivakeKeyAlias,
 598             _tostring(password),
 599             ckmMessage,
 600             ckmHashAlgo,
 601             ckmPadding,
 602             ckmSignature)) != CKM_API_SUCCESS) {
 603         return to_ckmc_error(ret);
 604     }
 605
 606     ret = ckmc_buffer_new( ckmSignature.data(), ckmSignature.size(), signature);
 607
 608     return ret;
 609 }
 610
 611 KEY_MANAGER_CAPI
 612 int ckmc_verify_signature(const char *public_key_alias,
 613                             const char *password,
 614                             const ckmc_raw_buffer_s message,
 615                             const ckmc_raw_buffer_s signature,
 616                             const ckmc_hash_algo_e hash,
 617                             const ckmc_rsa_padding_algo_e padding)
 618 {
 619     int ret;
 620     CKM::ManagerShPtr mgr = CKM::Manager::create();
 621
 622     if(public_key_alias == NULL) {
 623         return CKMC_ERROR_INVALID_PARAMETER;
 624     }
 625
 626     CKM::Alias ckmPublicKeyAlias(public_key_alias);
 627     CKM::RawBuffer ckmMessage(message.data, message.data + message.size);
 628     CKM::RawBuffer ckmSignature(signature.data, signature.data + signature.size);
 629     CKM::HashAlgorithm ckmHashAlgo = static_cast<CKM::HashAlgorithm>(static_cast<int>(hash));
 630     CKM::RSAPaddingAlgorithm ckmPadding = static_cast<CKM::RSAPaddingAlgorithm>(static_cast<int>(padding));
 631
 632     if( (ret = mgr->verifySignature(
 633             ckmPublicKeyAlias,
 634             _tostring(password),
 635             ckmMessage,
 636             ckmSignature,
 637             ckmHashAlgo,
 638             ckmPadding)) != CKM_API_SUCCESS) {
 639         return to_ckmc_error(ret);
 640     }
 641
 642     return CKMC_ERROR_NONE;
 643 }
 644
 645 KEY_MANAGER_CAPI
 646 int ckmc_get_cert_chain(const ckmc_cert_s *cert, const ckmc_cert_list_s *untrustedcerts, ckmc_cert_list_s **cert_chain_list)
 647 {
 648     int ret;
 649     CKM::ManagerShPtr mgr = CKM::Manager::create();
 650     CKM::CertificateShPtrVector ckmCertChain;
 651
 652     if(cert == NULL || cert->raw_cert == NULL || cert->cert_size <= 0 || cert_chain_list == NULL) {
 653         return CKMC_ERROR_INVALID_PARAMETER;
 654     }
 655
 656     CKM::CertificateShPtr ckmCert = _toCkmCertificate(cert);
 657
 658     CKM::CertificateShPtrVector ckmUntrustedCerts = _toCkmCertificateVector(untrustedcerts);
 659
 660     ret = mgr->getCertificateChain(ckmCert, ckmUntrustedCerts, EMPTY_CERT_VECTOR, true, ckmCertChain);
 661     if( ret != CKM_API_SUCCESS) {
 662         return to_ckmc_error(ret);
 663     }
 664
 665     *cert_chain_list = _toNewCkmCertList(ckmCertChain);
 666
 667     return CKMC_ERROR_NONE;
 668 }
 669
 670 KEY_MANAGER_CAPI
 671 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)
 672 {
 673     int ret;
 674     CKM::ManagerShPtr mgr = CKM::Manager::create();
 675     CKM::CertificateShPtrVector ckmCertChain;
 676
 677
 678     if(cert == NULL || cert->raw_cert == NULL || cert->cert_size <= 0 || cert_chain_list == NULL) {
 679         return CKMC_ERROR_INVALID_PARAMETER;
 680     }
 681
 682     CKM::CertificateShPtr ckmCert = _toCkmCertificate(cert);
 683     if(ckmCert.get() == NULL) {
 684         return CKMC_ERROR_INVALID_FORMAT;
 685     }
 686
 687     CKM::AliasVector ckmUntrustedAliases = _toCkmAliasVector(untrustedcerts);
 688
 689     ret = mgr->getCertificateChain(ckmCert, ckmUntrustedAliases, EMPTY_ALIAS_VECTOR, true, ckmCertChain);
 690     if( ret != CKM_API_SUCCESS) {
 691         return to_ckmc_error(ret);
 692     }
 693
 694     *cert_chain_list = _toNewCkmCertList(ckmCertChain);
 695
 696     return CKMC_ERROR_NONE;
 697 }
 698
 699 KEY_MANAGER_CAPI
 700 int ckmc_get_certificate_chain(const ckmc_cert_s* cert,
 701                                const ckmc_cert_list_s* untrustedcerts,
 702                                const ckmc_cert_list_s* trustedcerts,
 703                                const bool sys_certs,
 704                                ckmc_cert_list_s** ppcert_chain_list)
 705 {
 706     int ret;
 707     CKM::ManagerShPtr mgr = CKM::Manager::create();
 708     CKM::CertificateShPtrVector ckm_cert_chain;
 709
 710     if(cert == NULL || cert->raw_cert == NULL || cert->cert_size <= 0 || ppcert_chain_list == NULL) {
 711         return CKMC_ERROR_INVALID_PARAMETER;
 712     }
 713
 714     CKM::CertificateShPtr ckm_cert = _toCkmCertificate(cert);
 715     if(ckm_cert.get() == NULL) {
 716         return CKMC_ERROR_INVALID_PARAMETER;
 717     }
 718
 719     CKM::CertificateShPtrVector ckm_untrusted = _toCkmCertificateVector(untrustedcerts);
 720     CKM::CertificateShPtrVector ckm_trusted = _toCkmCertificateVector(trustedcerts);
 721
 722     ret = mgr->getCertificateChain(ckm_cert, ckm_untrusted, ckm_trusted, sys_certs, ckm_cert_chain);
 723     if( ret != CKM_API_SUCCESS) {
 724         return to_ckmc_error(ret);
 725     }
 726
 727     *ppcert_chain_list = _toNewCkmCertList(ckm_cert_chain);
 728
 729     return CKMC_ERROR_NONE;
 730 }
 731
 732 KEY_MANAGER_CAPI
 733 int ckmc_get_certificate_chain_with_alias(const ckmc_cert_s* cert,
 734                                           const ckmc_alias_list_s* untrustedcerts,
 735                                           const ckmc_alias_list_s* trustedcerts,
 736                                           const bool sys_certs,
 737                                           ckmc_cert_list_s** ppcert_chain_list)
 738 {
 739     int ret;
 740     CKM::ManagerShPtr mgr = CKM::Manager::create();
 741     CKM::CertificateShPtrVector ckm_cert_chain;
 742
 743     if(cert == NULL || cert->raw_cert == NULL || cert->cert_size <= 0 || ppcert_chain_list == NULL) {
 744         return CKMC_ERROR_INVALID_PARAMETER;
 745     }
 746
 747     CKM::CertificateShPtr ckm_cert = _toCkmCertificate(cert);
 748     if(ckm_cert.get() == NULL) {
 749         return CKMC_ERROR_INVALID_PARAMETER;
 750     }
 751
 752     CKM::AliasVector ckm_untrusted = _toCkmAliasVector(untrustedcerts);
 753     CKM::AliasVector ckm_trusted = _toCkmAliasVector(trustedcerts);
 754
 755     ret = mgr->getCertificateChain(ckm_cert, ckm_untrusted, ckm_trusted, sys_certs, ckm_cert_chain);
 756     if( ret != CKM_API_SUCCESS) {
 757         return to_ckmc_error(ret);
 758     }
 759
 760     *ppcert_chain_list = _toNewCkmCertList(ckm_cert_chain);
 761
 762     return CKMC_ERROR_NONE;
 763 }
 764
 765 KEY_MANAGER_CAPI
 766 int ckmc_ocsp_check(const ckmc_cert_list_s *pcert_chain_list, ckmc_ocsp_status_e *ocsp_status)
 767 {
 768     if (pcert_chain_list == NULL
 769         || pcert_chain_list->cert == NULL
 770         || pcert_chain_list->cert->raw_cert == NULL
 771         || pcert_chain_list->cert->cert_size <= 0
 772         || ocsp_status == NULL) {
 773         return CKMC_ERROR_INVALID_PARAMETER;
 774     }
 775
 776     int ret = CKMC_ERROR_UNKNOWN;
 777     int tmpOcspStatus = -1;
 778     CKM::ManagerShPtr mgr = CKM::Manager::create();
 779     CKM::CertificateShPtrVector ckmCertChain;
 780     const ckmc_cert_list_s *current = NULL;
 781     const ckmc_cert_list_s *next = pcert_chain_list;
 782
 783     do {
 784         current = next;
 785         next = current->next;
 786         if (current->cert == NULL)
 787             continue;
 788
 789         ckmCertChain.push_back(_toCkmCertificate(current->cert));
 790     } while (next != NULL);
 791
 792     ret = mgr->ocspCheck(ckmCertChain, tmpOcspStatus);
 793     *ocsp_status = to_ckmc_ocsp_status(tmpOcspStatus);
 794     return to_ckmc_error(ret);
 795 }
 796
 797 KEY_MANAGER_CAPI
 798 int ckmc_allow_access(const char *alias, const char *accessor, ckmc_access_right_e granted)
 799 {
 800     return ckmc_set_permission(alias, accessor, static_cast<int>(granted));
 801 }
 802
 803 KEY_MANAGER_CAPI
 804 int ckmc_set_permission(const char *alias, const char *accessor, int permissions)
 805 {
 806     if (!alias || !accessor)
 807         return CKMC_ERROR_INVALID_PARAMETER;
 808
 809     CKM::ManagerShPtr mgr = CKM::Manager::create();
 810     return to_ckmc_error(mgr->setPermission(alias, accessor, permissions));
 811 }
 812
 813 KEY_MANAGER_CAPI
 814 int ckmc_deny_access(const char *alias, const char *accessor)
 815 {
 816     if (!alias || !accessor)
 817         return CKMC_ERROR_INVALID_PARAMETER;
 818
 819     CKM::ManagerShPtr mgr = CKM::Manager::create();
 820     return to_ckmc_error(mgr->setPermission(alias, accessor, CKM::Permission::NONE));
 821 }
 822
 823 KEY_MANAGER_CAPI
 824 int ckmc_remove_alias(const char *alias)
 825 {
 826     if(!alias)
 827         return CKMC_ERROR_INVALID_PARAMETER;
 828
 829     CKM::ManagerShPtr mgr = CKM::Manager::create();
 830     int ret =  mgr->removeAlias(alias);
 831     return to_ckmc_error(ret);
 832 }