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