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