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 <iostream>
  29 #include <string.h>
  30
  31 bool _toBool(ckmc_bool ckmBool)
  32 {
  33         if(ckmBool == CKMC_TRUE) {
  34                 return true;
  35         }
  36         return false;
  37 }
  38
  39 std::string _tostring(const char *str)
  40 {
  41         if(str == NULL)
  42                 return std::string();
  43         return std::string(str);
  44 }
  45
  46 CKM::CertificateShPtr _toCkmCertificate(const ckmc_cert *cert)
  47 {
  48         CKM::RawBuffer buffer(cert->raw_cert, cert->raw_cert + cert->cert_size);
  49         CKM::DataFormat dataFormat = static_cast<CKM::DataFormat>(static_cast<int>(cert->data_format));
  50         return CKM::Certificate::create(buffer, dataFormat);
  51 }
  52
  53 ckmc_cert_list *_toNewCkmCertList(CKM::CertificateShPtrVector &certVector)
  54 {
  55         ckmc_cert_list *start = NULL;
  56         ckmc_cert_list *plist = NULL;
  57         CKM::CertificateShPtrVector::iterator it;
  58         for(it = certVector.begin(); it != certVector.end(); it++) {
  59                 CKM::RawBuffer rawBuffer = (*it)->getDER();
  60                 unsigned char *rawCert = (unsigned char *) malloc(rawBuffer.size());
  61                 memcpy(rawCert, rawBuffer.data(), rawBuffer.size());
  62                 ckmc_cert *pcert = ckmc_cert_new( rawCert, rawBuffer.size(), CKMC_FORM_DER);
  63                 if(pcert == NULL) {
  64                         return NULL;
  65                 }
  66                 if(plist == NULL) {
  67                         plist = ckmc_cert_list_new(pcert);
  68                         start = plist; // save the pointer of the first element
  69                 }else {
  70                         plist = ckmc_cert_list_add(plist, pcert);
  71                 }
  72         }
  73         return start;
  74 }
  75
  76 KEY_MANAGER_CAPI
  77 int ckmc_save_key(const char *alias, const ckmc_key key, const ckmc_policy policy)
  78 {
  79         CKM::ManagerShPtr mgr = CKM::Manager::create();
  80
  81         if(alias == NULL) {
  82                 return CKMC_API_ERROR_INPUT_PARAM;
  83         }
  84         CKM::Alias ckmAlias(alias);
  85
  86         if(key.raw_key == NULL || key.key_size <= 0) {
  87                         return CKMC_API_ERROR_INPUT_PARAM;
  88         }
  89         CKM::RawBuffer buffer(key.raw_key, key.raw_key + key.key_size);
  90         CKM::KeyShPtr ckmKey = CKM::Key::create(buffer, _tostring(key.password));
  91
  92         if(ckmKey.get() == NULL) {
  93                 return CKMC_API_ERROR_INVALID_FORMAT;
  94         }
  95
  96         CKM::Policy storePolicy(_tostring(policy.password), _toBool(policy.extractable), _toBool(policy.restricted));
  97
  98         return mgr->saveKey(ckmAlias, ckmKey, storePolicy);
  99 }
 100
 101
 102 KEY_MANAGER_CAPI
 103 int ckmc_remove_key(const char *alias)
 104 {
 105         CKM::ManagerShPtr mgr = CKM::Manager::create();
 106
 107         if(alias == NULL) {
 108                 return CKMC_API_ERROR_INPUT_PARAM;
 109         }
 110         CKM::Alias ckmAlias(alias);
 111
 112         return mgr->removeKey(ckmAlias);
 113 }
 114
 115 KEY_MANAGER_CAPI
 116 int ckmc_get_key(const char *alias, const char *password, ckmc_key **key)
 117 {
 118         int ret;
 119         CKM::KeyShPtr ckmKey;
 120
 121         if(alias == NULL || key == NULL) {
 122                 return CKMC_API_ERROR_INPUT_PARAM;
 123         }
 124         CKM::Alias ckmAlias(alias);
 125
 126         CKM::ManagerShPtr mgr = CKM::Manager::create();
 127         if( (ret = mgr->getKey(ckmAlias, _tostring(password), ckmKey)) != CKMC_API_SUCCESS) {
 128                 return ret;
 129         }
 130
 131         unsigned char *rawKey = reinterpret_cast<unsigned char*>(ckmKey->getDER().data());
 132         ckmc_key_type keyType = static_cast<ckmc_key_type>(static_cast<int>(ckmKey->getType()));
 133         *key = ckmc_key_new( rawKey, ckmKey->getDER().size(), keyType, NULL);
 134         if(*key == NULL) {
 135                 return CKMC_API_ERROR_OUT_OF_MEMORY;
 136         }else {
 137                 return CKMC_API_SUCCESS;
 138         }
 139 }
 140
 141 KEY_MANAGER_CAPI
 142 int ckmc_get_key_alias_list(ckmc_alias_list** alias_list)
 143 {
 144         int ret;
 145
 146         if(alias_list == NULL) {
 147                 return CKMC_API_ERROR_INPUT_PARAM;
 148         }
 149
 150         CKM::AliasVector aliasVector;
 151         CKM::ManagerShPtr mgr = CKM::Manager::create();
 152         if( (ret = mgr->getKeyAliasVector(aliasVector)) != CKMC_API_SUCCESS) {
 153                 return ret;
 154         }
 155
 156         ckmc_alias_list *plist = NULL;
 157         CKM::AliasVector::iterator it;
 158         for(it = aliasVector.begin(); it != aliasVector.end(); it++) {
 159                 char *alias = (char *)malloc(it->size() + 1);
 160                 memset(alias, 0, it->size() +1 );
 161                 memcpy(alias, it->c_str(), it->size());
 162                 if(plist == NULL) { // first
 163                         plist = ckmc_alias_list_new(alias);
 164                         *alias_list = plist; // save the pointer of the first element
 165                 }else {
 166                         plist = ckmc_alias_list_add(plist, alias);
 167                 }
 168         }
 169
 170         return CKMC_API_SUCCESS;
 171 }
 172
 173 KEY_MANAGER_CAPI
 174 int ckmc_save_cert(const char *alias, const ckmc_cert cert, const ckmc_policy policy)
 175 {
 176         if(alias == NULL) {
 177                 return CKMC_API_ERROR_INPUT_PARAM;
 178         }
 179         CKM::Alias ckmAlias(alias);
 180
 181         if(cert.raw_cert == NULL || cert.cert_size <= 0) {
 182                         return CKMC_API_ERROR_INPUT_PARAM;
 183         }
 184         CKM::CertificateShPtr ckmCert = _toCkmCertificate(&cert);
 185         if(ckmCert.get() == NULL) {
 186                 return CKMC_API_ERROR_INVALID_FORMAT;
 187         }
 188
 189         CKM::Policy storePolicy(_tostring(policy.password), _toBool(policy.extractable), _toBool(policy.restricted));
 190
 191         CKM::ManagerShPtr mgr = CKM::Manager::create();
 192         return mgr->saveCertificate(ckmAlias, ckmCert, storePolicy);
 193 }
 194
 195 KEY_MANAGER_CAPI
 196 int ckmc_remove_cert(const char *alias)
 197 {
 198         if(alias == NULL) {
 199                 return CKMC_API_ERROR_INPUT_PARAM;
 200         }
 201         CKM::Alias ckmAlias(alias);
 202
 203         CKM::ManagerShPtr mgr = CKM::Manager::create();
 204         return mgr->removeCertificate(ckmAlias);
 205 }
 206
 207 KEY_MANAGER_CAPI
 208 int ckmc_get_cert(const char *alias, const char *password, ckmc_cert **cert)
 209 {
 210         CKM::CertificateShPtr ckmCert;
 211         int ret;
 212
 213         if(alias == NULL || cert == NULL) {
 214                 return CKMC_API_ERROR_INPUT_PARAM;
 215         }
 216         CKM::Alias ckmAlias(alias);
 217
 218         CKM::ManagerShPtr mgr = CKM::Manager::create();
 219         if( (ret = mgr->getCertificate(ckmAlias, _tostring(password), ckmCert)) != CKMC_API_SUCCESS) {
 220                 return ret;
 221         }
 222
 223         unsigned char *rawCert = reinterpret_cast<unsigned char*>(ckmCert->getDER().data());
 224         *cert = ckmc_cert_new( rawCert, ckmCert->getDER().size(), CKMC_FORM_DER);
 225         if(*cert == NULL) {
 226                 return CKMC_API_ERROR_OUT_OF_MEMORY;
 227         }else {
 228                 return CKMC_API_SUCCESS;
 229         }
 230 }
 231
 232 KEY_MANAGER_CAPI
 233 int ckmc_get_cert_alias_list(ckmc_alias_list** alias_list) {
 234         int ret;
 235
 236         if(alias_list == NULL) {
 237                 return CKMC_API_ERROR_INPUT_PARAM;
 238         }
 239
 240         CKM::AliasVector aliasVector;
 241         CKM::ManagerShPtr mgr = CKM::Manager::create();
 242         if( (ret = mgr->getCertificateAliasVector(aliasVector)) != CKMC_API_SUCCESS) {
 243                 return ret;
 244         }
 245
 246         ckmc_alias_list *plist = NULL;
 247         CKM::AliasVector::iterator it;
 248         for(it = aliasVector.begin(); it != aliasVector.end(); it++) {
 249                 char *alias = (char *)malloc(it->size() + 1);
 250                 memset(alias, 0, it->size() +1 );
 251                 memcpy(alias, it->c_str(), it->size());
 252                 if(plist == NULL) { // first
 253                         plist = ckmc_alias_list_new(alias);
 254                         *alias_list = plist; // save the pointer of the first element
 255                 }else {
 256                         plist = ckmc_alias_list_add(plist, alias);
 257                 }
 258         }
 259
 260         return CKMC_API_SUCCESS;
 261 }
 262
 263 KEY_MANAGER_CAPI
 264 int ckmc_save_data(const char *alias, ckmc_raw_buffer data, const ckmc_policy policy)
 265 {
 266         if(alias == NULL) {
 267                 return CKMC_API_ERROR_INPUT_PARAM;
 268         }
 269         CKM::Alias ckmAlias(alias);
 270
 271         if(data.data == NULL || data.size <= 0) {
 272                         return CKMC_API_ERROR_INPUT_PARAM;
 273         }
 274         CKM::RawBuffer buffer(data.data, data.data + data.size);
 275
 276         CKM::Policy storePolicy(_tostring(policy.password), _toBool(policy.extractable), _toBool(policy.restricted));
 277
 278         CKM::ManagerShPtr mgr = CKM::Manager::create();
 279         return mgr->saveData(ckmAlias, buffer, storePolicy);
 280 }
 281
 282 KEY_MANAGER_CAPI
 283 int ckmc_remove_data(const char *alias)
 284 {
 285         if(alias == NULL) {
 286                 return CKMC_API_ERROR_INPUT_PARAM;
 287         }
 288         CKM::Alias ckmAlias(alias);
 289
 290         CKM::ManagerShPtr mgr = CKM::Manager::create();
 291         return mgr->removeData(ckmAlias);
 292 }
 293
 294 KEY_MANAGER_CAPI
 295 int ckmc_get_data(const char *alias, const char *password, ckmc_raw_buffer **data)
 296 {
 297         CKM::RawBuffer ckmBuff;
 298         int ret;
 299
 300         if(alias == NULL || data == NULL) {
 301                 return CKMC_API_ERROR_INPUT_PARAM;
 302         }
 303         CKM::Alias ckmAlias(alias);
 304
 305         CKM::ManagerShPtr mgr = CKM::Manager::create();
 306         if( (ret = mgr->getData(ckmAlias, _tostring(password), ckmBuff)) != CKMC_API_SUCCESS) {
 307                 return ret;
 308         }
 309
 310         unsigned char *rawBuff = reinterpret_cast<unsigned char*>(ckmBuff.data());
 311         *data = ckmc_buffer_new( rawBuff, ckmBuff.size());
 312         if(*data == NULL) {
 313                 return CKMC_API_ERROR_OUT_OF_MEMORY;
 314         }else {
 315                 return CKMC_API_SUCCESS;
 316         }
 317 }
 318
 319 KEY_MANAGER_CAPI
 320 int ckmc_get_data_alias_list(ckmc_alias_list** alias_list){
 321         int ret;
 322
 323         if(alias_list == NULL) {
 324                 return CKMC_API_ERROR_INPUT_PARAM;
 325         }
 326
 327         CKM::AliasVector aliasVector;
 328         CKM::ManagerShPtr mgr = CKM::Manager::create();
 329         if( (ret = mgr->getDataAliasVector(aliasVector)) != CKMC_API_SUCCESS) {
 330                 return ret;
 331         }
 332
 333         ckmc_alias_list *plist = NULL;
 334         CKM::AliasVector::iterator it;
 335         for(it = aliasVector.begin(); it != aliasVector.end(); it++) {
 336                 char *alias = (char *)malloc(it->size() + 1);
 337                 memset(alias, 0, it->size() +1 );
 338                 memcpy(alias, it->c_str(), it->size());
 339                 if(plist == NULL) { // first
 340                         plist = ckmc_alias_list_new(alias);
 341                         *alias_list = plist; // save the pointer of the first element
 342                 }else {
 343                         plist = ckmc_alias_list_add(plist, alias);
 344                 }
 345         }
 346
 347         return CKMC_API_SUCCESS;
 348 }
 349
 350 KEY_MANAGER_CAPI
 351 int ckmc_create_key_pair_rsa(const size_t size,
 352                                                         const char *private_key_alias,
 353                                                         const char *public_key_alias,
 354                                                         const ckmc_policy policy_private_key,
 355                                                         const ckmc_policy policy_public_key)
 356 {
 357         int ret;
 358         CKM::ManagerShPtr mgr = CKM::Manager::create();
 359
 360         if(private_key_alias == NULL || public_key_alias == NULL) {
 361                 return CKMC_API_ERROR_INPUT_PARAM;
 362         }
 363
 364         CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 365         CKM::Alias ckmPublicKeyAlias(public_key_alias);
 366         CKM::Policy ckmPrivateKeyPolicy(_tostring(policy_private_key.password), _toBool(policy_private_key.extractable), _toBool(policy_private_key.restricted));
 367         CKM::Policy ckmPublicKeyPolicy(_tostring(policy_public_key.password), _toBool(policy_public_key.extractable), _toBool(policy_public_key.restricted));
 368
 369         if( (ret = mgr->createKeyPairRSA(size, ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy))
 370                         != CKMC_API_SUCCESS) {
 371                 return ret;
 372         }
 373
 374         return CKMC_API_SUCCESS;
 375 }
 376
 377 KEY_MANAGER_CAPI
 378 int ckmc_create_key_pair_ecdsa(const ckmc_ec_type type,
 379                                                         const char *private_key_alias,
 380                                                         const char *public_key_alias,
 381                                                         const ckmc_policy policy_private_key,
 382                                                         const ckmc_policy policy_public_key)
 383 {
 384         CKM::ManagerShPtr mgr = CKM::Manager::create();
 385
 386         if(private_key_alias == NULL || public_key_alias == NULL) {
 387                 return CKMC_API_ERROR_INPUT_PARAM;
 388         }
 389
 390         CKM::ElipticCurve ckmType = static_cast<CKM::ElipticCurve>(static_cast<int>(type));
 391         CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 392         CKM::Alias ckmPublicKeyAlias(public_key_alias);
 393         CKM::Policy ckmPrivateKeyPolicy(_tostring(policy_private_key.password), _toBool(policy_private_key.extractable), _toBool(policy_private_key.restricted));
 394         CKM::Policy ckmPublicKeyPolicy(_tostring(policy_public_key.password), _toBool(policy_public_key.extractable), _toBool(policy_public_key.restricted));
 395
 396         return mgr->createKeyPairECDSA(ckmType, ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy);
 397 }
 398
 399 KEY_MANAGER_CAPI
 400 int ckmc_create_signature(const char *private_key_alias,
 401                                                         const char *password,
 402                                                         const ckmc_raw_buffer message,
 403                                                         const ckmc_hash_algo hash,
 404                                                         const ckmc_rsa_padding_algo padding,
 405                                                         ckmc_raw_buffer **signature)
 406 {
 407         int ret;
 408         CKM::ManagerShPtr mgr = CKM::Manager::create();
 409         CKM::RawBuffer ckmSignature;
 410
 411         if(private_key_alias == NULL || signature == NULL) {
 412                 return CKMC_API_ERROR_INPUT_PARAM;
 413         }
 414
 415         CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 416         CKM::RawBuffer ckmMessage(message.data, message.data + message.size);
 417         CKM::HashAlgorithm ckmHashAlgo = static_cast<CKM::HashAlgorithm>(static_cast<int>(hash));
 418         CKM::RSAPaddingAlgorithm ckmPadding = static_cast<CKM::RSAPaddingAlgorithm>(static_cast<int>(padding));
 419
 420         if( (ret = mgr->createSignature(
 421                         ckmPrivakeKeyAlias,
 422                         _tostring(password),
 423                         ckmMessage,
 424                         ckmHashAlgo,
 425                         ckmPadding,
 426                         ckmSignature)) != CKMC_API_SUCCESS) {
 427                 return ret;
 428         }
 429
 430         unsigned char *rawBuff = reinterpret_cast<unsigned char*>(ckmSignature.data());
 431         *signature = ckmc_buffer_new( rawBuff, ckmSignature.size());
 432         if(*signature == NULL) {
 433                 return CKMC_API_ERROR_OUT_OF_MEMORY;
 434         }else {
 435                 return CKMC_API_SUCCESS;
 436         }
 437
 438         return CKMC_API_SUCCESS;
 439 }
 440
 441 KEY_MANAGER_CAPI
 442 int ckmc_verify_signature(const char *public_key_alias,
 443                                                         const char *password,
 444                                                         const ckmc_raw_buffer message,
 445                                                         const ckmc_raw_buffer signature,
 446                                                         const ckmc_hash_algo hash,
 447                                                         const ckmc_rsa_padding_algo padding)
 448 {
 449         int ret;
 450         CKM::ManagerShPtr mgr = CKM::Manager::create();
 451
 452         if(public_key_alias == NULL) {
 453                 return CKMC_API_ERROR_INPUT_PARAM;
 454         }
 455
 456         CKM::Alias ckmPublicKeyAlias(public_key_alias);
 457         CKM::RawBuffer ckmMessage(message.data, message.data + message.size);
 458         CKM::RawBuffer ckmSignature(signature.data, signature.data + signature.size);
 459         CKM::HashAlgorithm ckmHashAlgo = static_cast<CKM::HashAlgorithm>(static_cast<int>(hash));
 460         CKM::RSAPaddingAlgorithm ckmPadding = static_cast<CKM::RSAPaddingAlgorithm>(static_cast<int>(padding));
 461
 462         if( (ret = mgr->verifySignature(
 463                         ckmPublicKeyAlias,
 464                         _tostring(password),
 465                         ckmMessage,
 466                         ckmSignature,
 467                         ckmHashAlgo,
 468                         ckmPadding)) != CKMC_API_SUCCESS) {
 469                 return ret;
 470         }
 471
 472         return CKMC_API_SUCCESS;
 473 }
 474
 475 KEY_MANAGER_CAPI
 476 int ckmc_get_cert_chain(const ckmc_cert *cert, const ckmc_cert_list *untrustedcerts, ckmc_cert_list **cert_chain_list)
 477 {
 478         int ret;
 479         CKM::ManagerShPtr mgr = CKM::Manager::create();
 480         CKM::CertificateShPtrVector ckmCertChain;
 481
 482         if(cert == NULL || cert->raw_cert == NULL || cert->cert_size <= 0 || cert_chain_list == NULL) {
 483                 return CKMC_API_ERROR_INPUT_PARAM;
 484         }
 485
 486         CKM::CertificateShPtr ckmCert = _toCkmCertificate(cert);
 487
 488         CKM::CertificateShPtrVector ckmUntrustedCerts;
 489         if(untrustedcerts != NULL) {
 490                 ckmc_cert_list *current = NULL;
 491                 ckmc_cert_list *next = const_cast<ckmc_cert_list *>(untrustedcerts);
 492                 do {
 493                         current = next;
 494                         next = current->next;
 495
 496                         if(current->cert == NULL){
 497                                 continue;
 498                         }
 499
 500                         CKM::CertificateShPtr tmpCkmCert = _toCkmCertificate(current->cert);
 501                         ckmUntrustedCerts.push_back(tmpCkmCert);
 502                 }while(next != NULL);
 503         }
 504
 505         ret = mgr->getCertificateChain(ckmCert, ckmUntrustedCerts, ckmCertChain);
 506         if( ret != CKMC_API_SUCCESS) {
 507                 return ret;
 508         }
 509
 510         *cert_chain_list = _toNewCkmCertList(ckmCertChain);
 511
 512         return CKMC_API_SUCCESS;
 513 }
 514
 515 KEY_MANAGER_CAPI
 516 int ckmc_get_cert_chain_with_alias(const ckmc_cert *cert, const ckmc_alias_list *untrustedcerts, ckmc_cert_list **cert_chain_list)
 517 {
 518         int ret;
 519         CKM::ManagerShPtr mgr = CKM::Manager::create();
 520         CKM::CertificateShPtrVector ckmCertChain;
 521
 522
 523         if(cert == NULL || cert->raw_cert == NULL || cert->cert_size <= 0 || cert_chain_list == NULL) {
 524                 return CKMC_API_ERROR_INPUT_PARAM;
 525         }
 526
 527     CKM::CertificateShPtr ckmCert = _toCkmCertificate(cert);
 528         if(ckmCert.get() == NULL) {
 529                 return CKMC_API_ERROR_INVALID_FORMAT;
 530         }
 531
 532         CKM::AliasVector ckmUntrustedAliases;
 533         if(untrustedcerts != NULL) {
 534                 ckmc_alias_list *current = NULL;
 535                 ckmc_alias_list *next = const_cast<ckmc_alias_list *>(untrustedcerts);
 536                 do {
 537                         current = next;
 538                         next = current->next;
 539
 540                         if(current->alias == NULL){
 541                                 return CKMC_API_ERROR_INPUT_PARAM;
 542                         }
 543                         CKM::Alias ckmAlias(current->alias);
 544                         ckmUntrustedAliases.push_back(ckmAlias);
 545                 }while(next != NULL);
 546         }
 547
 548         if( (ret = mgr->getCertificateChain(ckmCert, ckmUntrustedAliases, ckmCertChain)) != CKMC_API_SUCCESS) {
 549                 return ret;
 550         }
 551
 552         *cert_chain_list = _toNewCkmCertList(ckmCertChain);
 553
 554         return CKMC_API_SUCCESS;
 555 }
 556