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         CKM::Manager mgr;
 325
 326         CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 327         CKM::Alias ckmPublicKeyAlias(public_key_alias);
 328         CKM::Policy ckmPrivateKeyPolicy(policy_private_key.password, _toBool(policy_private_key.extractable), _toBool(policy_private_key.restricted));
 329         CKM::Policy ckmPublicKeyPolicy(policy_public_key.password, _toBool(policy_public_key.extractable), _toBool(policy_public_key.restricted));
 330
 331     return mgr.createKeyPairRSA(size, ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy);
 332 }
 333
 334 KEY_MANAGER_CAPI
 335 int ckm_create_key_pair_ecdsa(const ckm_ec_type type,
 336                                                         const char *private_key_alias,
 337                                                         const char *public_key_alias,
 338                                                         const ckm_policy policy_private_key,
 339                                                         const ckm_policy policy_public_key)
 340 {
 341         CKM::Manager mgr;
 342
 343         CKM::ElipticCurve ckmType = static_cast<CKM::ElipticCurve>(static_cast<int>(type));
 344         CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 345         CKM::Alias ckmPublicKeyAlias(public_key_alias);
 346         CKM::Policy ckmPrivateKeyPolicy(policy_private_key.password, _toBool(policy_private_key.extractable), _toBool(policy_private_key.restricted));
 347         CKM::Policy ckmPublicKeyPolicy(policy_public_key.password, _toBool(policy_public_key.extractable), _toBool(policy_public_key.restricted));
 348
 349         return mgr.createKeyPairECDSA(ckmType, ckmPrivakeKeyAlias, ckmPublicKeyAlias, ckmPrivateKeyPolicy, ckmPublicKeyPolicy);
 350 }
 351
 352 KEY_MANAGER_CAPI
 353 int ckm_create_signature(const char *private_key_alias,
 354                                                         const char *password,
 355                                                         const ckm_raw_buffer message,
 356                                                         const ckm_hash_algo hash,
 357                                                         const ckm_rsa_padding_algo padding,
 358                                                         ckm_raw_buffer **signature)
 359 {
 360         int ret;
 361         CKM::Manager mgr;
 362         CKM::RawBuffer ckmSignature;
 363
 364         CKM::Alias ckmPrivakeKeyAlias(private_key_alias);
 365         CKM::RawBuffer ckmMessage(message.data, message.data + message.size);
 366         CKM::HashAlgorithm ckmHashAlgo = static_cast<CKM::HashAlgorithm>(static_cast<int>(hash));
 367         CKM::RSAPaddingAlgorithm ckmPadding = static_cast<CKM::RSAPaddingAlgorithm>(static_cast<int>(padding));
 368
 369         if( (ret = mgr.createSignature(
 370                         ckmPrivakeKeyAlias,
 371                         password,
 372                         ckmMessage,
 373                         ckmHashAlgo,
 374                         ckmPadding,
 375                         ckmSignature)) != CKM_API_SUCCESS) {
 376                 return ret;
 377         }
 378
 379         unsigned char *rawBuff = reinterpret_cast<unsigned char*>(ckmSignature.data());
 380         *signature = ckm_buffer_new( rawBuff, ckmSignature.size());
 381         if(*signature == NULL) {
 382                 return CKM_API_ERROR_OUT_OF_MEMORY;
 383         }else {
 384                 return CKM_API_SUCCESS;
 385         }
 386
 387         return CKM_API_SUCCESS;
 388 }
 389
 390 KEY_MANAGER_CAPI
 391 int ckm_verify_signature(const char *public_key_alias,
 392                                                         const char *password,
 393                                                         const ckm_raw_buffer message,
 394                                                         const ckm_raw_buffer signature,
 395                                                         const ckm_hash_algo hash,
 396                                                         const ckm_rsa_padding_algo padding)
 397 {
 398         int ret;
 399         CKM::Manager mgr;
 400
 401         CKM::Alias ckmPublicKeyAlias(public_key_alias);
 402         CKM::RawBuffer ckmMessage(message.data, message.data + message.size);
 403         CKM::RawBuffer ckmSignature(signature.data, signature.data + signature.size);
 404         CKM::HashAlgorithm ckmHashAlgo = static_cast<CKM::HashAlgorithm>(static_cast<int>(hash));
 405         CKM::RSAPaddingAlgorithm ckmPadding = static_cast<CKM::RSAPaddingAlgorithm>(static_cast<int>(padding));
 406
 407         if( (ret = mgr.verifySignature(
 408                         ckmPublicKeyAlias,
 409                         password,
 410                         ckmMessage,
 411                         ckmSignature,
 412                         ckmHashAlgo,
 413                         ckmPadding)) != CKM_API_SUCCESS) {
 414                 return ret;
 415         }
 416
 417         return CKM_API_SUCCESS;
 418 }
 419
 420 KEY_MANAGER_CAPI
 421 int ckm_get_cert_chain(const ckm_cert *cert, const ckm_cert_list *untrustedcerts, ckm_cert_list **cert_chain_list)
 422 {
 423         int ret;
 424         CKM::Manager mgr;
 425         CKM::CertificateVector ckmCertChain;
 426
 427
 428         if(cert->raw_cert == NULL || cert->cert_size <= 0) {
 429                 return CKM_API_ERROR_INPUT_PARAM;
 430         }
 431         CKM::RawBuffer buffer(cert->raw_cert, cert->raw_cert + cert->cert_size);
 432         CKM::DataFormat dataFormat = static_cast<CKM::DataFormat>(static_cast<int>(cert->data_format));
 433         CKM::Certificate ckmCert(buffer, dataFormat);
 434
 435         CKM::CertificateVector ckmUntrustedCerts;
 436         if(untrustedcerts != NULL) {
 437                 ckm_cert_list *current = NULL;
 438                 ckm_cert_list *next = const_cast<ckm_cert_list *>(untrustedcerts);
 439                 do {
 440                         current = next;
 441                         next = current->next;
 442
 443                         if(current->cert == NULL){
 444                                 return CKM_API_ERROR_INPUT_PARAM;
 445                         }
 446                         CKM::Certificate ckmCert = _toCkmCertificate(current->cert);
 447                         ckmUntrustedCerts.push_back(ckmCert);
 448                 }while(next != NULL);
 449         }
 450
 451         if( (ret = mgr.getCertificateChain(ckmCert, ckmUntrustedCerts, ckmCertChain)) != CKM_API_SUCCESS) {
 452                 return ret;
 453         }
 454
 455         *cert_chain_list = _toNewCkmCertList(ckmCertChain);
 456
 457         return CKM_API_SUCCESS;
 458 }
 459
 460 KEY_MANAGER_CAPI
 461 int ckm_get_cert_chain_with_alias(const ckm_cert *cert, const ckm_alias_list *untrustedcerts, ckm_cert_list **cert_chain_list)
 462 {
 463         int ret;
 464         CKM::Manager mgr;
 465         CKM::CertificateVector ckmCertChain;
 466
 467
 468         if(cert->raw_cert == NULL || cert->cert_size <= 0) {
 469                 return CKM_API_ERROR_INPUT_PARAM;
 470         }
 471         CKM::RawBuffer buffer(cert->raw_cert, cert->raw_cert + cert->cert_size);
 472         CKM::DataFormat dataFormat = static_cast<CKM::DataFormat>(static_cast<int>(cert->data_format));
 473         CKM::Certificate ckmCert(buffer, dataFormat);
 474
 475         CKM::AliasVector ckmUntrustedAliases;
 476         if(untrustedcerts != NULL) {
 477                 ckm_alias_list *current = NULL;
 478                 ckm_alias_list *next = const_cast<ckm_alias_list *>(untrustedcerts);
 479                 do {
 480                         current = next;
 481                         next = current->next;
 482
 483                         if(current->alias == NULL){
 484                                 return CKM_API_ERROR_INPUT_PARAM;
 485                         }
 486                         CKM::Alias ckmAlias(current->alias);
 487                         ckmUntrustedAliases.push_back(ckmAlias);
 488                 }while(next != NULL);
 489         }
 490
 491         if( (ret = mgr.getCertificateChain(ckmCert, ckmUntrustedAliases, ckmCertChain)) != CKM_API_SUCCESS) {
 492                 return ret;
 493         }
 494
 495         *cert_chain_list = _toNewCkmCertList(ckmCertChain);
 496
 497         return CKM_API_SUCCESS;
 498 }
 499