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