src/manager/client/client-manager-impl.cpp

   1 /* Copyright (c) 2014-2020 Samsung Electronics Co., Ltd. All rights reserved
   2  *
   3  *  Licensed under the Apache License, Version 2.0 (the "License");
   4  *  you may not use this file except in compliance with the License.
   5  *  You may obtain a copy of the License at
   6  *
   7  *      http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  *  Unless required by applicable law or agreed to in writing, software
  10  *  distributed under the License is distributed on an "AS IS" BASIS,
  11  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  *  See the License for the specific language governing permissions and
  13  *  limitations under the License
  14  *
  15  *
  16  * @file        client-manager-impl.cpp
  17  * @author      Bartlomiej Grzelewski (b.grzelewski@samsung.com)
  18  * @version     1.0
  19  * @brief       Manager implementation.
  20  */
  21 #include <openssl/evp.h>
  22
  23 #include <dpl/serialization.h>
  24 #include <dpl/log/log.h>
  25
  26 #include <client-manager-impl.h>
  27 #include <client-common.h>
  28 #include <exception.h>
  29 #include <message-buffer.h>
  30 #include <protocols.h>
  31 #include <key-impl.h>
  32 #include <key-aes-impl.h>
  33 #include <certificate-impl.h>
  34
  35 namespace CKM {
  36
  37 namespace {
  38 template <class...T>
  39 int deserialize(const int msgId, MessageBuffer &recv, T&&...t)
  40 {
  41         int retMsgId, retCode;
  42         recv.Deserialize(retMsgId, retCode, std::forward<T>(t)...);
  43         return msgId != retMsgId ? CKM_API_ERROR_UNKNOWN : retCode;
  44 }
  45
  46 template <class T>
  47 int getCertChain(
  48         ServiceConnection &serviceConnection,
  49         LogicCommand command,
  50         int msgId,
  51         const CertificateShPtr &certificate,
  52         const T &untrustedVector,
  53         const T &trustedVector,
  54         bool useTrustedSystemCertificates,
  55         CertificateShPtrVector &certificateChainVector)
  56 {
  57         EXCEPTION_GUARD_START_CPPAPI
  58
  59         MessageBuffer recv;
  60         auto send = SerializeMessage(static_cast<int>(command),
  61                                                                  msgId,
  62                                                                  certificate->getDER(),
  63                                                                  untrustedVector,
  64                                                                  trustedVector,
  65                                                                  useTrustedSystemCertificates);
  66
  67         int retCode = serviceConnection.processRequest(send, recv);
  68
  69         if (CKM_API_SUCCESS != retCode)
  70                 return retCode;
  71
  72         RawBufferVector rawBufferVector;
  73         retCode = deserialize(msgId, recv, rawBufferVector);
  74
  75         if (retCode != CKM_API_SUCCESS)
  76                 return retCode;
  77
  78         for (auto &e : rawBufferVector) {
  79                 CertificateShPtr cert(new CertificateImpl(e, DataFormat::FORM_DER));
  80
  81                 if (cert->empty())
  82                         return CKM_API_ERROR_BAD_RESPONSE;
  83
  84                 certificateChainVector.push_back(cert);
  85         }
  86
  87         return retCode;
  88
  89         EXCEPTION_GUARD_END
  90 }
  91
  92 } // namespace anonymous
  93
  94 Manager::Impl::Impl()
  95         : m_counter(0),
  96           m_storageConnection(SERVICE_SOCKET_CKM_STORAGE),
  97           m_ocspConnection(SERVICE_SOCKET_OCSP),
  98           m_encryptionConnection(SERVICE_SOCKET_ENCRYPTION)
  99 {
 100 }
 101
 102
 103 int Manager::Impl::saveBinaryData(
 104         const Alias &alias,
 105         DataType dataType,
 106         const RawBuffer &rawData,
 107         const Policy &policy)
 108 {
 109         int msgId = ++m_counter;
 110
 111         EXCEPTION_GUARD_START_CPPAPI
 112
 113         if (alias.empty() || rawData.empty())
 114                 return CKM_API_ERROR_INPUT_PARAM;
 115
 116         MessageBuffer recv;
 117         AliasSupport helper(alias);
 118         auto send = SerializeMessage(static_cast<int>(LogicCommand::SAVE),
 119                                                                  msgId,
 120                                                                  dataType,
 121                                                                  helper.getName(),
 122                                                                  helper.getOwner(),
 123                                                                  rawData,
 124                                                                  PolicySerializable(policy));
 125
 126         int retCode = m_storageConnection.processRequest(send, recv);
 127
 128         if (CKM_API_SUCCESS != retCode)
 129                 return retCode;
 130
 131         int opType;
 132         return deserialize(msgId, recv, opType);
 133
 134         EXCEPTION_GUARD_END
 135 }
 136
 137 int Manager::Impl::saveKey(const Alias &alias, const KeyShPtr &key,
 138                                                    const Policy &policy)
 139 {
 140         if (key.get() == NULL || key->empty())
 141                 return CKM_API_ERROR_INPUT_PARAM;
 142
 143         try {
 144                 return saveBinaryData(alias, DataType(key->getType()), key->getDER(), policy);
 145         } catch (const Exc::Exception &e) {
 146                 LogError("Exception: " << e.what());
 147                 return e.error();
 148         }
 149 }
 150
 151 int Manager::Impl::saveCertificate(
 152         const Alias &alias,
 153         const CertificateShPtr &cert,
 154         const Policy &policy)
 155 {
 156         if (cert.get() == NULL || cert->empty())
 157                 return CKM_API_ERROR_INPUT_PARAM;
 158
 159         return saveBinaryData(alias, DataType::CERTIFICATE, cert->getDER(), policy);
 160 }
 161
 162 int Manager::Impl::saveData(const Alias &alias, const RawBuffer &rawData,
 163                                                         const Policy &policy)
 164 {
 165         if (!policy.extractable)
 166                 return CKM_API_ERROR_INPUT_PARAM;
 167
 168         return saveBinaryData(alias, DataType::BINARY_DATA, rawData, policy);
 169 }
 170
 171
 172 int Manager::Impl::savePKCS12(
 173         const Alias &alias,
 174         const PKCS12ShPtr &pkcs,
 175         const Policy &keyPolicy,
 176         const Policy &certPolicy)
 177 {
 178         if (alias.empty() || pkcs.get() == NULL)
 179                 return CKM_API_ERROR_INPUT_PARAM;
 180
 181         int msgId = ++m_counter;
 182
 183         EXCEPTION_GUARD_START_CPPAPI
 184
 185         MessageBuffer recv;
 186         AliasSupport helper(alias);
 187         auto send = SerializeMessage(static_cast<int>(LogicCommand::SAVE_PKCS12),
 188                                                                  msgId,
 189                                                                  helper.getName(),
 190                                                                  helper.getOwner(),
 191                                                                  PKCS12Serializable(*pkcs.get()),
 192                                                                  PolicySerializable(keyPolicy),
 193                                                                  PolicySerializable(certPolicy));
 194
 195         int retCode = m_storageConnection.processRequest(send, recv);
 196
 197         if (CKM_API_SUCCESS != retCode)
 198                 return retCode;
 199
 200         return deserialize(msgId, recv);
 201
 202         EXCEPTION_GUARD_END
 203 }
 204
 205 int Manager::Impl::getPKCS12(const Alias &alias, PKCS12ShPtr &pkcs)
 206 {
 207         return getPKCS12(alias, Password(), Password(), pkcs);
 208 }
 209
 210 int Manager::Impl::getPKCS12(const Alias &alias, const Password &keyPass,
 211                                                          const Password &certPass, PKCS12ShPtr &pkcs)
 212 {
 213         if (alias.empty())
 214                 return CKM_API_ERROR_INPUT_PARAM;
 215
 216         int msgId = ++m_counter;
 217
 218         EXCEPTION_GUARD_START_CPPAPI
 219
 220         MessageBuffer recv;
 221         AliasSupport helper(alias);
 222         auto send = SerializeMessage(static_cast<int>(LogicCommand::GET_PKCS12),
 223                                                                  msgId,
 224                                                                  helper.getName(),
 225                                                                  helper.getOwner(),
 226                                                                  keyPass,
 227                                                                  certPass);
 228
 229         int retCode = m_storageConnection.processRequest(send, recv);
 230
 231         if (CKM_API_SUCCESS != retCode)
 232                 return retCode;
 233
 234         int retMsgId;
 235         PKCS12Serializable gotPkcs;
 236         recv.Deserialize(retMsgId, retCode, gotPkcs);
 237
 238         if (retMsgId != msgId)
 239                 return CKM_API_ERROR_UNKNOWN;
 240
 241         pkcs = std::make_shared<PKCS12Impl>(std::move(gotPkcs));
 242
 243         return retCode;
 244
 245         EXCEPTION_GUARD_END
 246 }
 247
 248
 249 int Manager::Impl::removeAlias(const Alias &alias)
 250 {
 251         if (alias.empty())
 252                 return CKM_API_ERROR_INPUT_PARAM;
 253
 254         int msgId = ++m_counter;
 255
 256         EXCEPTION_GUARD_START_CPPAPI
 257
 258         MessageBuffer recv;
 259         AliasSupport helper(alias);
 260         auto send = SerializeMessage(static_cast<int>(LogicCommand::REMOVE),
 261                                                                  msgId,
 262                                                                  helper.getName(),
 263                                                                  helper.getOwner());
 264
 265         int retCode = m_storageConnection.processRequest(send, recv);
 266
 267         if (CKM_API_SUCCESS != retCode)
 268                 return retCode;
 269
 270         return deserialize(msgId, recv);
 271
 272         EXCEPTION_GUARD_END
 273 }
 274
 275 int Manager::Impl::getBinaryData(
 276         const Alias &alias,
 277         DataType sendDataType,
 278         const Password &password,
 279         DataType &recvDataType,
 280         RawBuffer &rawData)
 281 {
 282         if (alias.empty())
 283                 return CKM_API_ERROR_INPUT_PARAM;
 284
 285         int msgId = ++m_counter;
 286
 287         EXCEPTION_GUARD_START_CPPAPI
 288
 289         MessageBuffer recv;
 290         AliasSupport helper(alias);
 291         auto send = SerializeMessage(static_cast<int>(LogicCommand::GET),
 292                                                                  msgId,
 293                                                                  sendDataType,
 294                                                                  helper.getName(),
 295                                                                  helper.getOwner(),
 296                                                                  password);
 297
 298         int retCode = m_storageConnection.processRequest(send, recv);
 299
 300         if (CKM_API_SUCCESS != retCode)
 301                 return retCode;
 302
 303         return deserialize(msgId, recv, recvDataType, rawData);
 304
 305         EXCEPTION_GUARD_END
 306 }
 307
 308 int Manager::Impl::getBinaryDataEncryptionStatus(const DataType sendDataType,
 309                                                 const Alias &alias, bool &status)
 310 {
 311         status = false;
 312         if (alias.empty())
 313                 return CKM_API_ERROR_INPUT_PARAM;
 314
 315         int msgId = ++m_counter;
 316
 317         EXCEPTION_GUARD_START_CPPAPI
 318
 319         MessageBuffer recv;
 320         AliasSupport helper(alias);
 321         auto send = SerializeMessage(static_cast<int>(LogicCommand::GET_PROTECTION_STATUS),
 322                                                                  msgId,
 323                                                                  sendDataType,
 324                                                                  helper.getName(),
 325                                                                  helper.getOwner());
 326
 327         int retCode = m_storageConnection.processRequest(send, recv);
 328
 329         if (CKM_API_SUCCESS != retCode)
 330                 return retCode;
 331
 332         DataType tmpDataType;
 333         bool passwordProtectionStatus;
 334         retCode = deserialize(msgId, recv, tmpDataType, passwordProtectionStatus);
 335
 336         if (retCode != CKM_API_SUCCESS) {
 337                 return retCode;
 338         } else {
 339                 status = passwordProtectionStatus;
 340                 return CKM_API_SUCCESS;
 341         }
 342         EXCEPTION_GUARD_END
 343 }
 344
 345 int Manager::Impl::getKey(const Alias &alias, const Password &password,
 346                                                   KeyShPtr &key)
 347 {
 348         DataType recvDataType;
 349         RawBuffer rawData;
 350
 351         int retCode = getBinaryData(
 352                                           alias,
 353                                           DataType::KEY_RSA_PUBLIC,
 354                                           password,
 355                                           recvDataType,
 356                                           rawData);
 357
 358         if (retCode != CKM_API_SUCCESS)
 359                 return retCode;
 360
 361         KeyShPtr keyParsed;
 362
 363         if (recvDataType.isSKey())
 364                 keyParsed = Key::createAES(rawData);
 365         else
 366                 keyParsed = Key::create(rawData);
 367
 368         if (!keyParsed) {
 369                 LogDebug("Key empty - failed to parse!");
 370                 return CKM_API_ERROR_BAD_RESPONSE;
 371         }
 372
 373         key = keyParsed;
 374
 375         return CKM_API_SUCCESS;
 376 }
 377
 378 int Manager::Impl::getCertificate(const Alias &alias, const Password &password,
 379                                                                   CertificateShPtr &cert)
 380 {
 381         DataType recvDataType;
 382         RawBuffer rawData;
 383
 384         int retCode = getBinaryData(
 385                                           alias,
 386                                           DataType::CERTIFICATE,
 387                                           password,
 388                                           recvDataType,
 389                                           rawData);
 390
 391         if (retCode != CKM_API_SUCCESS)
 392                 return retCode;
 393
 394         if (!recvDataType.isCertificate())
 395                 return CKM_API_ERROR_BAD_RESPONSE;
 396
 397         CertificateShPtr certParsed(new CertificateImpl(rawData, DataFormat::FORM_DER));
 398
 399         if (certParsed->empty())
 400                 return CKM_API_ERROR_BAD_RESPONSE;
 401
 402         cert = certParsed;
 403
 404         return CKM_API_SUCCESS;
 405 }
 406
 407 int Manager::Impl::getData(const Alias &alias, const Password &password,
 408                                                    RawBuffer &rawData)
 409 {
 410         DataType recvDataType = DataType::BINARY_DATA;
 411
 412         int retCode = getBinaryData(
 413                                           alias,
 414                                           DataType::BINARY_DATA,
 415                                           password,
 416                                           recvDataType,
 417                                           rawData);
 418
 419         if (retCode != CKM_API_SUCCESS)
 420                 return retCode;
 421
 422         if (!recvDataType.isBinaryData())
 423                 return CKM_API_ERROR_BAD_RESPONSE;
 424
 425         return CKM_API_SUCCESS;
 426 }
 427
 428 int Manager::Impl::getBinaryDataAliasVectorHelper(DataType dataType,
 429                 OwnerNameVector &ownerNameVector)
 430 {
 431         int msgId = ++m_counter;
 432
 433         MessageBuffer recv;
 434         auto send = SerializeMessage(static_cast<int>(LogicCommand::GET_LIST), msgId, dataType);
 435
 436         int retCode = m_storageConnection.processRequest(send, recv);
 437
 438         if (retCode != CKM_API_SUCCESS)
 439                 return retCode;
 440
 441         int retMsgId;
 442         DataType tmpDataType;
 443         recv.Deserialize(retMsgId, retCode, tmpDataType, ownerNameVector);
 444
 445         if (retMsgId != msgId)
 446                 return CKM_API_ERROR_UNKNOWN;
 447
 448         return CKM_API_SUCCESS;
 449 }
 450
 451 int Manager::Impl::getBinaryDataAliasVector(DataType dataType,
 452                 AliasVector &aliasVector)
 453 {
 454         EXCEPTION_GUARD_START_CPPAPI
 455         OwnerNameVector ownerNameVector;
 456         int retCode = getBinaryDataAliasVectorHelper(dataType, ownerNameVector);
 457
 458         if (retCode != CKM_API_SUCCESS)
 459                 return retCode;
 460
 461         for (const auto &it : ownerNameVector)
 462                 aliasVector.push_back(AliasSupport::merge(it.first, it.second));
 463
 464         return CKM_API_SUCCESS;
 465         EXCEPTION_GUARD_END
 466 }
 467
 468 int Manager::Impl::getBinaryDataAliasPwdVector(DataType dataType,
 469                 AliasPwdVector &aliasPwdVector)
 470 {
 471         EXCEPTION_GUARD_START_CPPAPI
 472         OwnerNameVector ownerNameVector;
 473         OwnerNameEncryptionStatusVector ownerNameEncryptionStatusVector;
 474         int retCode = getBinaryDataAliasVectorHelper(dataType, ownerNameVector);
 475
 476         if (retCode != CKM_API_SUCCESS)
 477                 return retCode;
 478
 479         for (const auto &it : ownerNameVector)
 480         {
 481                 Alias alias = AliasSupport::merge(std::get<0>(it), std::get<1>(it));
 482                 bool status;
 483                 retCode = getBinaryDataEncryptionStatus(dataType, alias, status);
 484
 485                 if (retCode != CKM_API_SUCCESS)
 486                         return retCode;
 487
 488                 aliasPwdVector.push_back(std::make_pair(alias, status));
 489         }
 490         return CKM_API_SUCCESS;
 491         EXCEPTION_GUARD_END
 492 }
 493
 494 int Manager::Impl::getKeyAliasVector(AliasVector &aliasVector)
 495 {
 496         // in fact datatype has no meaning here - if not certificate or binary data
 497         // then manager decides to list all between DB_KEY_FIRST and DB_KEY_LAST
 498         return getBinaryDataAliasVector(DataType::DB_KEY_LAST, aliasVector);
 499 }
 500
 501 int Manager::Impl::getCertificateAliasVector(AliasVector &aliasVector)
 502 {
 503         return getBinaryDataAliasVector(DataType::CERTIFICATE, aliasVector);
 504 }
 505
 506 int Manager::Impl::getDataAliasVector(AliasVector &aliasVector)
 507 {
 508         return getBinaryDataAliasVector(DataType::BINARY_DATA, aliasVector);
 509 }
 510
 511 int Manager::Impl::getKeyAliasPwdVector(AliasPwdVector &aliasPwdVector)
 512 {
 513         return getBinaryDataAliasPwdVector(DataType::DB_KEY_LAST, aliasPwdVector);
 514 }
 515
 516 int Manager::Impl::getKeyEncryptionStatus(const Alias &alias, bool &status)
 517 {
 518         return getBinaryDataEncryptionStatus(DataType::DB_KEY_LAST, alias, status);
 519 }
 520
 521 int Manager::Impl::getCertificateAliasPwdVector(AliasPwdVector &aliasPwdVector)
 522 {
 523         return getBinaryDataAliasPwdVector(DataType::CERTIFICATE, aliasPwdVector);
 524 }
 525
 526 int Manager::Impl::getCertificateEncryptionStatus(const Alias &alias, bool &status)
 527 {
 528         return getBinaryDataEncryptionStatus(DataType::CERTIFICATE, alias, status);
 529 }
 530
 531 int Manager::Impl::getDataAliasPwdVector(AliasPwdVector &aliasPwdVector)
 532 {
 533         return getBinaryDataAliasPwdVector(DataType::BINARY_DATA, aliasPwdVector);
 534 }
 535
 536 int Manager::Impl::getDataEncryptionStatus(const Alias &alias, bool &status)
 537 {
 538         return getBinaryDataEncryptionStatus(DataType::BINARY_DATA, alias, status);
 539 }
 540
 541 int Manager::Impl::createKeyPairRSA(
 542         const int size,
 543         const Alias &privateKeyAlias,
 544         const Alias &publicKeyAlias,
 545         const Policy &policyPrivateKey,
 546         const Policy &policyPublicKey)
 547 {
 548         return this->createKeyPair(CKM::KeyType::KEY_RSA_PUBLIC, size, privateKeyAlias,
 549                                                            publicKeyAlias, policyPrivateKey, policyPublicKey);
 550 }
 551
 552 int Manager::Impl::createKeyPairDSA(
 553         const int size,
 554         const Alias &privateKeyAlias,
 555         const Alias &publicKeyAlias,
 556         const Policy &policyPrivateKey,
 557         const Policy &policyPublicKey)
 558 {
 559         return this->createKeyPair(CKM::KeyType::KEY_DSA_PUBLIC, size, privateKeyAlias,
 560                                                            publicKeyAlias, policyPrivateKey, policyPublicKey);
 561 }
 562
 563 int Manager::Impl::createKeyPairECDSA(
 564         ElipticCurve type,
 565         const Alias &privateKeyAlias,
 566         const Alias &publicKeyAlias,
 567         const Policy &policyPrivateKey,
 568         const Policy &policyPublicKey)
 569 {
 570         return this->createKeyPair(CKM::KeyType::KEY_ECDSA_PUBLIC,
 571                                                            static_cast<int>(type), privateKeyAlias, publicKeyAlias, policyPrivateKey,
 572                                                            policyPublicKey);
 573 }
 574
 575 int Manager::Impl::createKeyAES(
 576         const int size,
 577         const Alias &keyAlias,
 578         const Policy &policyKey)
 579 {
 580         // proceed with sending request
 581         int msgId = ++m_counter;
 582
 583         EXCEPTION_GUARD_START_CPPAPI
 584
 585         MessageBuffer recv;
 586         AliasSupport aliasHelper(keyAlias);
 587         auto send = SerializeMessage(static_cast<int>(LogicCommand::CREATE_KEY_AES),
 588                                                                  msgId,
 589                                                                  static_cast<int>(size),
 590                                                                  PolicySerializable(policyKey),
 591                                                                  aliasHelper.getName(),
 592                                                                  aliasHelper.getOwner());
 593
 594         int retCode = m_storageConnection.processRequest(send, recv);
 595
 596         if (CKM_API_SUCCESS != retCode)
 597                 return retCode;
 598
 599         return deserialize(msgId, recv);
 600
 601         EXCEPTION_GUARD_END
 602 }
 603
 604
 605 int Manager::Impl::createKeyPair(
 606         const KeyType key_type,
 607         const int     additional_param,
 608         const Alias  &privateKeyAlias,
 609         const Alias  &publicKeyAlias,
 610         const Policy &policyPrivateKey,
 611         const Policy &policyPublicKey)
 612 {
 613         // input type check
 614         CryptoAlgorithm keyGenAlgorithm;
 615
 616         switch (key_type) {
 617         case KeyType::KEY_RSA_PUBLIC:
 618         case KeyType::KEY_RSA_PRIVATE:
 619                 keyGenAlgorithm.setParam(ParamName::ALGO_TYPE, AlgoType::RSA_GEN);
 620                 keyGenAlgorithm.setParam(ParamName::GEN_KEY_LEN, additional_param);
 621                 break;
 622
 623         case KeyType::KEY_DSA_PUBLIC:
 624         case KeyType::KEY_DSA_PRIVATE:
 625                 keyGenAlgorithm.setParam(ParamName::ALGO_TYPE, AlgoType::DSA_GEN);
 626                 keyGenAlgorithm.setParam(ParamName::GEN_KEY_LEN, additional_param);
 627                 break;
 628
 629         case KeyType::KEY_ECDSA_PUBLIC:
 630         case KeyType::KEY_ECDSA_PRIVATE:
 631                 keyGenAlgorithm.setParam(ParamName::ALGO_TYPE, AlgoType::ECDSA_GEN);
 632                 keyGenAlgorithm.setParam(ParamName::GEN_EC, additional_param);
 633                 break;
 634
 635         default:
 636                 return CKM_API_ERROR_INPUT_PARAM;
 637         }
 638
 639         // proceed with sending request
 640         int msgId = ++m_counter;
 641
 642         EXCEPTION_GUARD_START_CPPAPI
 643
 644         MessageBuffer recv;
 645         AliasSupport privateHelper(privateKeyAlias);
 646         AliasSupport publicHelper(publicKeyAlias);
 647         auto send = SerializeMessage(static_cast<int>(LogicCommand::CREATE_KEY_PAIR),
 648                                                                  msgId,
 649                                                                  CryptoAlgorithmSerializable(keyGenAlgorithm),
 650                                                                  PolicySerializable(policyPrivateKey),
 651                                                                  PolicySerializable(policyPublicKey),
 652                                                                  privateHelper.getName(),
 653                                                                  privateHelper.getOwner(),
 654                                                                  publicHelper.getName(),
 655                                                                  publicHelper.getOwner());
 656
 657         int retCode = m_storageConnection.processRequest(send, recv);
 658
 659         if (CKM_API_SUCCESS != retCode)
 660                 return retCode;
 661
 662         return deserialize(msgId, recv);
 663
 664         EXCEPTION_GUARD_END
 665 }
 666
 667 int Manager::Impl::getCertificateChain(
 668         const CertificateShPtr &certificate,
 669         const CertificateShPtrVector &untrustedCertificates,
 670         const CertificateShPtrVector &trustedCertificates,
 671         bool useTrustedSystemCertificates,
 672         CertificateShPtrVector &certificateChainVector)
 673 {
 674         RawBufferVector untrustedVector;
 675         RawBufferVector trustedVector;
 676
 677         if (!certificate || certificate->empty())
 678                 return CKM_API_ERROR_INPUT_PARAM;
 679
 680         for (auto &e : untrustedCertificates) {
 681                 if (!e || e->empty())
 682                         return CKM_API_ERROR_INPUT_PARAM;
 683                 untrustedVector.push_back(e->getDER());
 684         }
 685
 686         for (auto &e : trustedCertificates) {
 687                 if (!e || e->empty())
 688                         return CKM_API_ERROR_INPUT_PARAM;
 689                 trustedVector.push_back(e->getDER());
 690         }
 691
 692         return getCertChain(
 693                            m_storageConnection,
 694                            LogicCommand::GET_CHAIN_CERT,
 695                            ++m_counter,
 696                            certificate,
 697                            untrustedVector,
 698                            trustedVector,
 699                            useTrustedSystemCertificates,
 700                            certificateChainVector);
 701 }
 702
 703 int Manager::Impl::getCertificateChain(
 704         const CertificateShPtr &certificate,
 705         const AliasVector &untrustedCertificates,
 706         const AliasVector &trustedCertificates,
 707         bool useTrustedSystemCertificates,
 708         CertificateShPtrVector &certificateChainVector)
 709 {
 710         OwnerNameVector untrustedVector;
 711         OwnerNameVector trustedVector;
 712
 713         if (!certificate || certificate->empty())
 714                 return CKM_API_ERROR_INPUT_PARAM;
 715
 716         for (auto &e : untrustedCertificates) {
 717                 AliasSupport helper(e);
 718                 untrustedVector.push_back(std::make_pair(helper.getOwner(), helper.getName()));
 719         }
 720
 721         for (auto &e : trustedCertificates) {
 722                 AliasSupport helper(e);
 723                 trustedVector.push_back(std::make_pair(helper.getOwner(), helper.getName()));
 724         }
 725
 726         return getCertChain(
 727                            m_storageConnection,
 728                            LogicCommand::GET_CHAIN_ALIAS,
 729                            ++m_counter,
 730                            certificate,
 731                            untrustedVector,
 732                            trustedVector,
 733                            useTrustedSystemCertificates,
 734                            certificateChainVector);
 735 }
 736
 737 int Manager::Impl::createSignature(
 738         const Alias &privateKeyAlias,
 739         const Password &password,           // password for private_key
 740         const RawBuffer &message,
 741         const CryptoAlgorithm &cAlgorithm,
 742         RawBuffer &signature)
 743 {
 744         int msgId = ++m_counter;
 745
 746         EXCEPTION_GUARD_START_CPPAPI
 747
 748         MessageBuffer recv;
 749         AliasSupport helper(privateKeyAlias);
 750         auto send = SerializeMessage(static_cast<int>(LogicCommand::CREATE_SIGNATURE),
 751                                                                  msgId,
 752                                                                  helper.getName(),
 753                                                                  helper.getOwner(),
 754                                                                  password,
 755                                                                  message,
 756                                                                  CryptoAlgorithmSerializable(cAlgorithm));
 757
 758         int retCode = m_storageConnection.processRequest(send, recv);
 759
 760         if (CKM_API_SUCCESS != retCode)
 761                 return retCode;
 762
 763         return deserialize(msgId, recv, signature);
 764
 765         EXCEPTION_GUARD_END
 766 }
 767
 768 int Manager::Impl::verifySignature(
 769         const Alias &publicKeyOrCertAlias,
 770         const Password &password,           // password for public_key (optional)
 771         const RawBuffer &message,
 772         const RawBuffer &signature,
 773         const CryptoAlgorithm &cAlg)
 774 {
 775         int msgId = ++m_counter;
 776
 777         EXCEPTION_GUARD_START_CPPAPI
 778
 779         MessageBuffer recv;
 780         AliasSupport helper(publicKeyOrCertAlias);
 781         auto send = SerializeMessage(static_cast<int>(LogicCommand::VERIFY_SIGNATURE),
 782                                                                  msgId,
 783                                                                  helper.getName(),
 784                                                                  helper.getOwner(),
 785                                                                  password,
 786                                                                  message,
 787                                                                  signature,
 788                                                                  CryptoAlgorithmSerializable(cAlg));
 789
 790         int retCode = m_storageConnection.processRequest(send, recv);
 791
 792         if (CKM_API_SUCCESS != retCode)
 793                 return retCode;
 794
 795         return deserialize(msgId, recv);
 796
 797         EXCEPTION_GUARD_END
 798 }
 799
 800 int Manager::Impl::ocspCheck(const CertificateShPtrVector &certChain,
 801                                                          int &ocspStatus)
 802 {
 803         EXCEPTION_GUARD_START_CPPAPI
 804
 805         int msgId = ++m_counter;
 806         MessageBuffer recv;
 807
 808         RawBufferVector rawCertChain;
 809
 810         for (auto &e : certChain) {
 811                 if (!e || e->empty()) {
 812                         LogError("Empty certificate");
 813                         return CKM_API_ERROR_INPUT_PARAM;
 814                 }
 815
 816                 rawCertChain.push_back(e->getDER());
 817         }
 818
 819         auto send = SerializeMessage(msgId, rawCertChain);
 820
 821         int retCode = m_ocspConnection.processRequest(send, recv);
 822
 823         if (CKM_API_SUCCESS != retCode)
 824                 return retCode;
 825
 826         return deserialize(msgId, recv, ocspStatus);
 827
 828         EXCEPTION_GUARD_END
 829 }
 830
 831 int Manager::Impl::setPermission(const Alias &alias,
 832                                                                  const ClientId &accessor,
 833                                                                  PermissionMask permissionMask)
 834 {
 835         int msgId = ++m_counter;
 836
 837         EXCEPTION_GUARD_START_CPPAPI
 838
 839         MessageBuffer recv;
 840         AliasSupport helper(alias);
 841         auto send = SerializeMessage(static_cast<int>(LogicCommand::SET_PERMISSION),
 842                                                                  msgId,
 843                                                                  helper.getName(),
 844                                                                  helper.getOwner(),
 845                                                                  accessor,
 846                                                                  permissionMask);
 847
 848         int retCode = m_storageConnection.processRequest(send, recv);
 849
 850         if (CKM_API_SUCCESS != retCode)
 851                 return retCode;
 852
 853         return deserialize(msgId, recv);
 854
 855         EXCEPTION_GUARD_END
 856 }
 857
 858 int Manager::Impl::crypt(EncryptionCommand command,
 859                                                  const CryptoAlgorithm &algo,
 860                                                  const Alias &keyAlias,
 861                                                  const Password &password,
 862                                                  const RawBuffer &input,
 863                                                  RawBuffer &output)
 864 {
 865         int msgId = ++m_counter;
 866
 867         EXCEPTION_GUARD_START_CPPAPI
 868
 869         MessageBuffer recv;
 870         AliasSupport helper(keyAlias);
 871         CryptoAlgorithmSerializable cas(algo);
 872         auto send = SerializeMessage(static_cast<int>(command),
 873                                                                  msgId,
 874                                                                  cas,
 875                                                                  helper.getName(),
 876                                                                  helper.getOwner(),
 877                                                                  password,
 878                                                                  input);
 879
 880         int retCode = m_encryptionConnection.processRequest(send, recv);
 881
 882         if (CKM_API_SUCCESS != retCode)
 883                 return retCode;
 884
 885         return deserialize(msgId, recv, output);
 886
 887         EXCEPTION_GUARD_END
 888 }
 889
 890 int Manager::Impl::encrypt(const CryptoAlgorithm &algo,
 891                                                    const Alias &keyAlias,
 892                                                    const Password &password,
 893                                                    const RawBuffer &plain,
 894                                                    RawBuffer &encrypted)
 895 {
 896         return crypt(EncryptionCommand::ENCRYPT, algo, keyAlias, password, plain,
 897                                  encrypted);
 898 }
 899
 900 int Manager::Impl::decrypt(const CryptoAlgorithm &algo,
 901                                                    const Alias &keyAlias,
 902                                                    const Password &password,
 903                                                    const RawBuffer &encrypted,
 904                                                    RawBuffer &decrypted)
 905 {
 906         return crypt(EncryptionCommand::DECRYPT, algo, keyAlias, password, encrypted,
 907                                  decrypted);
 908 }
 909
 910 } // namespace CKM