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