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