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