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         int ret;
 389         CKM::Manager mgr;
 390
 391         if(private_key_alias == NULL || public_key_alias == NULL) {
 392                 return CKMC_API_ERROR_INPUT_PARAM;
 393         }
 394
 395         CKM::ElipticCurve ckmType = static_cast<CKM::ElipticCurve>(static_cast<int>(type));
 396         CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 397         CKM::Alias ckmPublicKeyAlias(public_key_alias);
 398         CKM::Policy ckmPrivateKeyPolicy(_tostring(policy_private_key.password), _toBool(policy_private_key.extractable), _toBool(policy_private_key.restricted));
 399         CKM::Policy ckmPublicKeyPolicy(_tostring(policy_public_key.password), _toBool(policy_public_key.extractable), _toBool(policy_public_key.restricted));
 400
 401         if( (ret - mgr.createKeyPairECDSA(ckmType, ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy))
 402                         != CKMC_API_SUCCESS) {
 403                 return ret;
 404         }
 405
 406         return CKMC_API_SUCCESS;
 407 }
 408
 409 KEY_MANAGER_CAPI
 410 int ckmc_create_signature(const char *private_key_alias,
 411                                                         const char *password,
 412                                                         const ckmc_raw_buffer message,
 413                                                         const ckmc_hash_algo hash,
 414                                                         const ckmc_rsa_padding_algo padding,
 415                                                         ckmc_raw_buffer **signature)
 416 {
 417         int ret;
 418         CKM::Manager mgr;
 419         CKM::RawBuffer ckmSignature;
 420
 421         if(private_key_alias == NULL || signature == NULL) {
 422                 return CKMC_API_ERROR_INPUT_PARAM;
 423         }
 424
 425         CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 426         CKM::RawBuffer ckmMessage(message.data, message.data + message.size);
 427         CKM::HashAlgorithm ckmHashAlgo = static_cast<CKM::HashAlgorithm>(static_cast<int>(hash));
 428         CKM::RSAPaddingAlgorithm ckmPadding = static_cast<CKM::RSAPaddingAlgorithm>(static_cast<int>(padding));
 429
 430         if( (ret = mgr.createSignature(
 431                         ckmPrivakeKeyAlias,
 432                         _tostring(password),
 433                         ckmMessage,
 434                         ckmHashAlgo,
 435                         ckmPadding,
 436                         ckmSignature)) != CKMC_API_SUCCESS) {
 437                 return ret;
 438         }
 439
 440         unsigned char *rawBuff = reinterpret_cast<unsigned char*>(ckmSignature.data());
 441         *signature = ckmc_buffer_new( rawBuff, ckmSignature.size());
 442         if(*signature == NULL) {
 443                 return CKMC_API_ERROR_OUT_OF_MEMORY;
 444         }else {
 445                 return CKMC_API_SUCCESS;
 446         }
 447
 448         return CKMC_API_SUCCESS;
 449 }
 450
 451 KEY_MANAGER_CAPI
 452 int ckmc_verify_signature(const char *public_key_alias,
 453                                                         const char *password,
 454                                                         const ckmc_raw_buffer message,
 455                                                         const ckmc_raw_buffer signature,
 456                                                         const ckmc_hash_algo hash,
 457                                                         const ckmc_rsa_padding_algo padding)
 458 {
 459         int ret;
 460         CKM::Manager mgr;
 461
 462         if(public_key_alias == NULL) {
 463                 return CKMC_API_ERROR_INPUT_PARAM;
 464         }
 465
 466         CKM::Alias ckmPublicKeyAlias(public_key_alias);
 467         CKM::RawBuffer ckmMessage(message.data, message.data + message.size);
 468         CKM::RawBuffer ckmSignature(signature.data, signature.data + signature.size);
 469         CKM::HashAlgorithm ckmHashAlgo = static_cast<CKM::HashAlgorithm>(static_cast<int>(hash));
 470         CKM::RSAPaddingAlgorithm ckmPadding = static_cast<CKM::RSAPaddingAlgorithm>(static_cast<int>(padding));
 471
 472         if( (ret = mgr.verifySignature(
 473                         ckmPublicKeyAlias,
 474                         _tostring(password),
 475                         ckmMessage,
 476                         ckmSignature,
 477                         ckmHashAlgo,
 478                         ckmPadding)) != CKMC_API_SUCCESS) {
 479                 return ret;
 480         }
 481
 482         return CKMC_API_SUCCESS;
 483 }
 484
 485 KEY_MANAGER_CAPI
 486 int ckmc_get_cert_chain(const ckmc_cert *cert, const ckmc_cert_list *untrustedcerts, ckmc_cert_list **cert_chain_list)
 487 {
 488         int ret;
 489         CKM::Manager mgr;
 490         CKM::CertificateVector ckmCertChain;
 491
 492         if(cert == NULL || cert->raw_cert == NULL || cert->cert_size <= 0 || cert_chain_list == NULL) {
 493                 return CKMC_API_ERROR_INPUT_PARAM;
 494         }
 495
 496         CKM::Certificate ckmCert = _toCkmCertificate(cert);
 497
 498         CKM::CertificateVector ckmUntrustedCerts;
 499         if(untrustedcerts != NULL) {
 500                 ckmc_cert_list *current = NULL;
 501                 ckmc_cert_list *next = const_cast<ckmc_cert_list *>(untrustedcerts);
 502                 do {
 503                         current = next;
 504                         next = current->next;
 505
 506                         if(current->cert == NULL){
 507                                 continue;
 508                         }
 509
 510                         CKM::Certificate tmpCkmCert = _toCkmCertificate(current->cert);
 511                         ckmUntrustedCerts.push_back(tmpCkmCert);
 512                 }while(next != NULL);
 513         }
 514
 515         ret = mgr.getCertificateChain(ckmCert, ckmUntrustedCerts, ckmCertChain);
 516         if( ret != CKMC_API_SUCCESS) {
 517                 return ret;
 518         }
 519
 520         *cert_chain_list = _toNewCkmCertList(ckmCertChain);
 521
 522         return CKMC_API_SUCCESS;
 523 }
 524
 525 KEY_MANAGER_CAPI
 526 int ckmc_get_cert_chain_with_alias(const ckmc_cert *cert, const ckmc_alias_list *untrustedcerts, ckmc_cert_list **cert_chain_list)
 527 {
 528         int ret;
 529         CKM::Manager mgr;
 530         CKM::CertificateVector ckmCertChain;
 531
 532
 533         if(cert == NULL || cert->raw_cert == NULL || cert->cert_size <= 0 || cert_chain_list == NULL) {
 534                 return CKMC_API_ERROR_INPUT_PARAM;
 535         }
 536         CKM::RawBuffer buffer(cert->raw_cert, cert->raw_cert + cert->cert_size);
 537         CKM::DataFormat dataFormat = static_cast<CKM::DataFormat>(static_cast<int>(cert->data_format));
 538         CKM::Certificate ckmCert(buffer, dataFormat);
 539
 540         CKM::AliasVector ckmUntrustedAliases;
 541         if(untrustedcerts != NULL) {
 542                 ckmc_alias_list *current = NULL;
 543                 ckmc_alias_list *next = const_cast<ckmc_alias_list *>(untrustedcerts);
 544                 do {
 545                         current = next;
 546                         next = current->next;
 547
 548                         if(current->alias == NULL){
 549                                 return CKMC_API_ERROR_INPUT_PARAM;
 550                         }
 551                         CKM::Alias ckmAlias(current->alias);
 552                         ckmUntrustedAliases.push_back(ckmAlias);
 553                 }while(next != NULL);
 554         }
 555
 556         if( (ret = mgr.getCertificateChain(ckmCert, ckmUntrustedAliases, ckmCertChain)) != CKMC_API_SUCCESS) {
 557                 return ret;
 558         }
 559
 560         *cert_chain_list = _toNewCkmCertList(ckmCertChain);
 561
 562         return CKMC_API_SUCCESS;
 563 }
 564