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