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