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