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                                                                                  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                                                                                  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         recv.Deserialize(retMsgId, retCode, recvDataType, rawData);
 322
 323         if (retMsgId != msgId)
 324                 return CKM_API_ERROR_UNKNOWN;
 325
 326         return retCode;
 327
 328         EXCEPTION_GUARD_END
 329 }
 330
 331 int Manager::Impl::getBinaryDataEncryptionStatus(const DataType sendDataType,
 332                                                 const Alias &alias, bool &status)
 333 {
 334         status = false;
 335         if (alias.empty())
 336                 return CKM_API_ERROR_INPUT_PARAM;
 337
 338         int msgId = ++m_counter;
 339
 340         EXCEPTION_GUARD_START_CPPAPI
 341
 342         MessageBuffer recv;
 343         AliasSupport helper(alias);
 344         auto send = MessageBuffer::Serialize(static_cast<int>(LogicCommand::GET_PROTECTION_STATUS),
 345                                                                                  msgId,
 346                                                                                  sendDataType,
 347                                                                                  helper.getName(),
 348                                                                                  helper.getOwner());
 349
 350         int retCode = m_storageConnection.processRequest(send.Pop(), recv);
 351
 352         if (CKM_API_SUCCESS != retCode)
 353                 return retCode;
 354
 355         int retMsgId;
 356         DataType tmpDataType;
 357         bool passwordProtectionStatus;
 358         recv.Deserialize(retMsgId, retCode, tmpDataType, passwordProtectionStatus);
 359
 360         if (retMsgId != msgId)
 361                 return CKM_API_ERROR_UNKNOWN;
 362
 363         if (retCode != CKM_API_SUCCESS) {
 364                 return retCode;
 365         } else {
 366                 status = passwordProtectionStatus;
 367                 return CKM_API_SUCCESS;
 368         }
 369         EXCEPTION_GUARD_END
 370 }
 371
 372 int Manager::Impl::getKey(const Alias &alias, const Password &password,
 373                                                   KeyShPtr &key)
 374 {
 375         DataType recvDataType;
 376         RawBuffer rawData;
 377
 378         int retCode = getBinaryData(
 379                                           alias,
 380                                           DataType::KEY_RSA_PUBLIC,
 381                                           password,
 382                                           recvDataType,
 383                                           rawData);
 384
 385         if (retCode != CKM_API_SUCCESS)
 386                 return retCode;
 387
 388         KeyShPtr keyParsed;
 389
 390         if (recvDataType.isSKey())
 391                 keyParsed = KeyShPtr(new KeyAESImpl(rawData));
 392         else
 393                 keyParsed = KeyShPtr(new KeyImpl(rawData));
 394
 395         if (keyParsed->empty()) {
 396                 LogDebug("Key empty - failed to parse!");
 397                 return CKM_API_ERROR_BAD_RESPONSE;
 398         }
 399
 400         key = keyParsed;
 401
 402         return CKM_API_SUCCESS;
 403 }
 404
 405 int Manager::Impl::getCertificate(const Alias &alias, const Password &password,
 406                                                                   CertificateShPtr &cert)
 407 {
 408         DataType recvDataType;
 409         RawBuffer rawData;
 410
 411         int retCode = getBinaryData(
 412                                           alias,
 413                                           DataType::CERTIFICATE,
 414                                           password,
 415                                           recvDataType,
 416                                           rawData);
 417
 418         if (retCode != CKM_API_SUCCESS)
 419                 return retCode;
 420
 421         if (!recvDataType.isCertificate())
 422                 return CKM_API_ERROR_BAD_RESPONSE;
 423
 424         CertificateShPtr certParsed(new CertificateImpl(rawData, DataFormat::FORM_DER));
 425
 426         if (certParsed->empty())
 427                 return CKM_API_ERROR_BAD_RESPONSE;
 428
 429         cert = certParsed;
 430
 431         return CKM_API_SUCCESS;
 432 }
 433
 434 int Manager::Impl::getData(const Alias &alias, const Password &password,
 435                                                    RawBuffer &rawData)
 436 {
 437         DataType recvDataType = DataType::BINARY_DATA;
 438
 439         int retCode = getBinaryData(
 440                                           alias,
 441                                           DataType::BINARY_DATA,
 442                                           password,
 443                                           recvDataType,
 444                                           rawData);
 445
 446         if (retCode != CKM_API_SUCCESS)
 447                 return retCode;
 448
 449         if (!recvDataType.isBinaryData())
 450                 return CKM_API_ERROR_BAD_RESPONSE;
 451
 452         return CKM_API_SUCCESS;
 453 }
 454
 455 int Manager::Impl::getBinaryDataAliasVectorHelper(DataType dataType,
 456                 OwnerNameVector &ownerNameVector)
 457 {
 458         int msgId = ++m_counter;
 459
 460         MessageBuffer recv;
 461         auto send = MessageBuffer::Serialize(static_cast<int>(LogicCommand::GET_LIST),
 462                                                                                  msgId,
 463                                                                                  dataType);
 464
 465         int retCode = m_storageConnection.processRequest(send.Pop(), recv);
 466
 467         if (retCode != CKM_API_SUCCESS)
 468                 return retCode;
 469
 470         int retMsgId;
 471         DataType tmpDataType;
 472         recv.Deserialize(retMsgId, retCode, tmpDataType, ownerNameVector);
 473
 474         if (retMsgId != msgId)
 475                 return CKM_API_ERROR_UNKNOWN;
 476
 477         return CKM_API_SUCCESS;
 478 }
 479
 480 int Manager::Impl::getBinaryDataAliasVector(DataType dataType,
 481                 AliasVector &aliasVector)
 482 {
 483         EXCEPTION_GUARD_START_CPPAPI
 484         OwnerNameVector ownerNameVector;
 485         int retCode = getBinaryDataAliasVectorHelper(dataType, ownerNameVector);
 486
 487         if (retCode != CKM_API_SUCCESS)
 488                 return retCode;
 489
 490         for (const auto &it : ownerNameVector)
 491                 aliasVector.push_back(AliasSupport::merge(it.first, it.second));
 492
 493         return CKM_API_SUCCESS;
 494         EXCEPTION_GUARD_END
 495 }
 496
 497 int Manager::Impl::getBinaryDataAliasPwdVector(DataType dataType,
 498                 AliasPwdVector &aliasPwdVector)
 499 {
 500         EXCEPTION_GUARD_START_CPPAPI
 501         OwnerNameVector ownerNameVector;
 502         OwnerNameEncryptionStatusVector ownerNameEncryptionStatusVector;
 503         int retCode = getBinaryDataAliasVectorHelper(dataType, ownerNameVector);
 504
 505         if (retCode != CKM_API_SUCCESS)
 506                 return retCode;
 507
 508         for (const auto &it : ownerNameVector)
 509         {
 510                 Alias alias = AliasSupport::merge(std::get<0>(it), std::get<1>(it));
 511                 bool status;
 512                 retCode = getBinaryDataEncryptionStatus(dataType, alias, status);
 513
 514                 if (retCode != CKM_API_SUCCESS)
 515                         return retCode;
 516
 517                 aliasPwdVector.push_back(std::make_pair(alias, status));
 518         }
 519         return CKM_API_SUCCESS;
 520         EXCEPTION_GUARD_END
 521 }
 522
 523 int Manager::Impl::getKeyAliasVector(AliasVector &aliasVector)
 524 {
 525         // in fact datatype has no meaning here - if not certificate or binary data
 526         // then manager decides to list all between DB_KEY_FIRST and DB_KEY_LAST
 527         return getBinaryDataAliasVector(DataType::DB_KEY_LAST, aliasVector);
 528 }
 529
 530 int Manager::Impl::getCertificateAliasVector(AliasVector &aliasVector)
 531 {
 532         return getBinaryDataAliasVector(DataType::CERTIFICATE, aliasVector);
 533 }
 534
 535 int Manager::Impl::getDataAliasVector(AliasVector &aliasVector)
 536 {
 537         return getBinaryDataAliasVector(DataType::BINARY_DATA, aliasVector);
 538 }
 539
 540 int Manager::Impl::getKeyAliasPwdVector(AliasPwdVector &aliasPwdVector)
 541 {
 542         return getBinaryDataAliasPwdVector(DataType::DB_KEY_LAST, aliasPwdVector);
 543 }
 544
 545 int Manager::Impl::getKeyEncryptionStatus(const Alias &alias, bool &status)
 546 {
 547         return getBinaryDataEncryptionStatus(DataType::DB_KEY_LAST, alias, status);
 548 }
 549
 550 int Manager::Impl::getCertificateAliasPwdVector(AliasPwdVector &aliasPwdVector)
 551 {
 552         return getBinaryDataAliasPwdVector(DataType::CERTIFICATE, aliasPwdVector);
 553 }
 554
 555 int Manager::Impl::getCertificateEncryptionStatus(const Alias &alias, bool &status)
 556 {
 557         return getBinaryDataEncryptionStatus(DataType::CERTIFICATE, alias, status);
 558 }
 559
 560 int Manager::Impl::getDataAliasPwdVector(AliasPwdVector &aliasPwdVector)
 561 {
 562         return getBinaryDataAliasPwdVector(DataType::BINARY_DATA, aliasPwdVector);
 563 }
 564
 565 int Manager::Impl::getDataEncryptionStatus(const Alias &alias, bool &status)
 566 {
 567         return getBinaryDataEncryptionStatus(DataType::BINARY_DATA, alias, status);
 568 }
 569
 570 int Manager::Impl::createKeyPairRSA(
 571         const int size,
 572         const Alias &privateKeyAlias,
 573         const Alias &publicKeyAlias,
 574         const Policy &policyPrivateKey,
 575         const Policy &policyPublicKey)
 576 {
 577         return this->createKeyPair(CKM::KeyType::KEY_RSA_PUBLIC, size, privateKeyAlias,
 578                                                            publicKeyAlias, policyPrivateKey, policyPublicKey);
 579 }
 580
 581 int Manager::Impl::createKeyPairDSA(
 582         const int size,
 583         const Alias &privateKeyAlias,
 584         const Alias &publicKeyAlias,
 585         const Policy &policyPrivateKey,
 586         const Policy &policyPublicKey)
 587 {
 588         return this->createKeyPair(CKM::KeyType::KEY_DSA_PUBLIC, size, privateKeyAlias,
 589                                                            publicKeyAlias, policyPrivateKey, policyPublicKey);
 590 }
 591
 592 int Manager::Impl::createKeyPairECDSA(
 593         ElipticCurve type,
 594         const Alias &privateKeyAlias,
 595         const Alias &publicKeyAlias,
 596         const Policy &policyPrivateKey,
 597         const Policy &policyPublicKey)
 598 {
 599         return this->createKeyPair(CKM::KeyType::KEY_ECDSA_PUBLIC,
 600                                                            static_cast<int>(type), privateKeyAlias, publicKeyAlias, policyPrivateKey,
 601                                                            policyPublicKey);
 602 }
 603
 604 int Manager::Impl::createKeyAES(
 605         const int size,
 606         const Alias &keyAlias,
 607         const Policy &policyKey)
 608 {
 609         // proceed with sending request
 610         int msgId = ++m_counter;
 611
 612         EXCEPTION_GUARD_START_CPPAPI
 613
 614         MessageBuffer recv;
 615         AliasSupport aliasHelper(keyAlias);
 616         auto send = MessageBuffer::Serialize(static_cast<int>
 617                                                                                  (LogicCommand::CREATE_KEY_AES),
 618                                                                                  msgId,
 619                                                                                  static_cast<int>(size),
 620                                                                                  PolicySerializable(policyKey),
 621                                                                                  aliasHelper.getName(),
 622                                                                                  aliasHelper.getOwner());
 623
 624         int retCode = m_storageConnection.processRequest(send.Pop(), recv);
 625
 626         if (CKM_API_SUCCESS != retCode)
 627                 return retCode;
 628
 629         int retMsgId;
 630         recv.Deserialize(retMsgId, retCode);
 631
 632         if (retMsgId != msgId)
 633                 return CKM_API_ERROR_UNKNOWN;
 634
 635         return retCode;
 636
 637         EXCEPTION_GUARD_END
 638 }
 639
 640
 641 int Manager::Impl::createKeyPair(
 642         const KeyType key_type,
 643         const int     additional_param,
 644         const Alias  &privateKeyAlias,
 645         const Alias  &publicKeyAlias,
 646         const Policy &policyPrivateKey,
 647         const Policy &policyPublicKey)
 648 {
 649         // input type check
 650         CryptoAlgorithm keyGenAlgorithm;
 651
 652         switch (key_type) {
 653         case KeyType::KEY_RSA_PUBLIC:
 654         case KeyType::KEY_RSA_PRIVATE:
 655                 keyGenAlgorithm.setParam(ParamName::ALGO_TYPE, AlgoType::RSA_GEN);
 656                 keyGenAlgorithm.setParam(ParamName::GEN_KEY_LEN, additional_param);
 657                 break;
 658
 659         case KeyType::KEY_DSA_PUBLIC:
 660         case KeyType::KEY_DSA_PRIVATE:
 661                 keyGenAlgorithm.setParam(ParamName::ALGO_TYPE, AlgoType::DSA_GEN);
 662                 keyGenAlgorithm.setParam(ParamName::GEN_KEY_LEN, additional_param);
 663                 break;
 664
 665         case KeyType::KEY_ECDSA_PUBLIC:
 666         case KeyType::KEY_ECDSA_PRIVATE:
 667                 keyGenAlgorithm.setParam(ParamName::ALGO_TYPE, AlgoType::ECDSA_GEN);
 668                 keyGenAlgorithm.setParam(ParamName::GEN_EC, additional_param);
 669                 break;
 670
 671         default:
 672                 return CKM_API_ERROR_INPUT_PARAM;
 673         }
 674
 675         // proceed with sending request
 676         int msgId = ++m_counter;
 677
 678         EXCEPTION_GUARD_START_CPPAPI
 679
 680         MessageBuffer recv;
 681         AliasSupport privateHelper(privateKeyAlias);
 682         AliasSupport publicHelper(publicKeyAlias);
 683         auto send = MessageBuffer::Serialize(static_cast<int>
 684                                                                                  (LogicCommand::CREATE_KEY_PAIR),
 685                                                                                  msgId,
 686                                                                                  CryptoAlgorithmSerializable(keyGenAlgorithm),
 687                                                                                  PolicySerializable(policyPrivateKey),
 688                                                                                  PolicySerializable(policyPublicKey),
 689                                                                                  privateHelper.getName(),
 690                                                                                  privateHelper.getOwner(),
 691                                                                                  publicHelper.getName(),
 692                                                                                  publicHelper.getOwner());
 693
 694         int retCode = m_storageConnection.processRequest(send.Pop(), recv);
 695
 696         if (CKM_API_SUCCESS != retCode)
 697                 return retCode;
 698
 699         int retMsgId;
 700         recv.Deserialize(retMsgId, retCode);
 701
 702         if (retMsgId != msgId)
 703                 return CKM_API_ERROR_UNKNOWN;
 704
 705         return retCode;
 706
 707         EXCEPTION_GUARD_END
 708 }
 709
 710 int Manager::Impl::getCertificateChain(
 711         const CertificateShPtr &certificate,
 712         const CertificateShPtrVector &untrustedCertificates,
 713         const CertificateShPtrVector &trustedCertificates,
 714         bool useTrustedSystemCertificates,
 715         CertificateShPtrVector &certificateChainVector)
 716 {
 717         RawBufferVector untrustedVector;
 718         RawBufferVector trustedVector;
 719
 720         if (!certificate || certificate->empty())
 721                 return CKM_API_ERROR_INPUT_PARAM;
 722
 723         for (auto &e : untrustedCertificates) {
 724                 if (!e || e->empty())
 725                         return CKM_API_ERROR_INPUT_PARAM;
 726                 untrustedVector.push_back(e->getDER());
 727         }
 728
 729         for (auto &e : trustedCertificates) {
 730                 if (!e || e->empty())
 731                         return CKM_API_ERROR_INPUT_PARAM;
 732                 trustedVector.push_back(e->getDER());
 733         }
 734
 735         return getCertChain(
 736                            m_storageConnection,
 737                            LogicCommand::GET_CHAIN_CERT,
 738                            ++m_counter,
 739                            certificate,
 740                            untrustedVector,
 741                            trustedVector,
 742                            useTrustedSystemCertificates,
 743                            certificateChainVector);
 744 }
 745
 746 int Manager::Impl::getCertificateChain(
 747         const CertificateShPtr &certificate,
 748         const AliasVector &untrustedCertificates,
 749         const AliasVector &trustedCertificates,
 750         bool useTrustedSystemCertificates,
 751         CertificateShPtrVector &certificateChainVector)
 752 {
 753         OwnerNameVector untrustedVector;
 754         OwnerNameVector trustedVector;
 755
 756         if (!certificate || certificate->empty())
 757                 return CKM_API_ERROR_INPUT_PARAM;
 758
 759         for (auto &e : untrustedCertificates) {
 760                 AliasSupport helper(e);
 761                 untrustedVector.push_back(std::make_pair(helper.getOwner(), helper.getName()));
 762         }
 763
 764         for (auto &e : trustedCertificates) {
 765                 AliasSupport helper(e);
 766                 trustedVector.push_back(std::make_pair(helper.getOwner(), helper.getName()));
 767         }
 768
 769         return getCertChain(
 770                            m_storageConnection,
 771                            LogicCommand::GET_CHAIN_ALIAS,
 772                            ++m_counter,
 773                            certificate,
 774                            untrustedVector,
 775                            trustedVector,
 776                            useTrustedSystemCertificates,
 777                            certificateChainVector);
 778 }
 779
 780 int Manager::Impl::createSignature(
 781         const Alias &privateKeyAlias,
 782         const Password &password,           // password for private_key
 783         const RawBuffer &message,
 784         const CryptoAlgorithm &cAlgorithm,
 785         RawBuffer &signature)
 786 {
 787         int msgId = ++m_counter;
 788
 789         EXCEPTION_GUARD_START_CPPAPI
 790
 791         MessageBuffer recv;
 792         AliasSupport helper(privateKeyAlias);
 793         auto send = MessageBuffer::Serialize(static_cast<int>
 794                                                                                  (LogicCommand::CREATE_SIGNATURE),
 795                                                                                  msgId,
 796                                                                                  helper.getName(),
 797                                                                                  helper.getOwner(),
 798                                                                                  password,
 799                                                                                  message,
 800                                                                                  CryptoAlgorithmSerializable(cAlgorithm));
 801
 802         int retCode = m_storageConnection.processRequest(send.Pop(), recv);
 803
 804         if (CKM_API_SUCCESS != retCode)
 805                 return retCode;
 806
 807         int retMsgId;
 808         recv.Deserialize(retMsgId, retCode, signature);
 809
 810         if (retMsgId != msgId)
 811                 return CKM_API_ERROR_UNKNOWN;
 812
 813         return retCode;
 814
 815         EXCEPTION_GUARD_END
 816 }
 817
 818 int Manager::Impl::verifySignature(
 819         const Alias &publicKeyOrCertAlias,
 820         const Password &password,           // password for public_key (optional)
 821         const RawBuffer &message,
 822         const RawBuffer &signature,
 823         const CryptoAlgorithm &cAlg)
 824 {
 825         int msgId = ++m_counter;
 826
 827         EXCEPTION_GUARD_START_CPPAPI
 828
 829         MessageBuffer recv;
 830         AliasSupport helper(publicKeyOrCertAlias);
 831         auto send = MessageBuffer::Serialize(static_cast<int>
 832                                                                                  (LogicCommand::VERIFY_SIGNATURE),
 833                                                                                  msgId,
 834                                                                                  helper.getName(),
 835                                                                                  helper.getOwner(),
 836                                                                                  password,
 837                                                                                  message,
 838                                                                                  signature,
 839                                                                                  CryptoAlgorithmSerializable(cAlg));
 840
 841         int retCode = m_storageConnection.processRequest(send.Pop(), recv);
 842
 843         if (CKM_API_SUCCESS != retCode)
 844                 return retCode;
 845
 846         int retMsgId;
 847         recv.Deserialize(retMsgId, retCode);
 848
 849         if (retMsgId != msgId)
 850                 return CKM_API_ERROR_UNKNOWN;
 851
 852         return retCode;
 853
 854         EXCEPTION_GUARD_END
 855 }
 856
 857 int Manager::Impl::ocspCheck(const CertificateShPtrVector &certChain,
 858                                                          int &ocspStatus)
 859 {
 860         EXCEPTION_GUARD_START_CPPAPI
 861
 862         int msgId = ++m_counter;
 863         MessageBuffer recv;
 864
 865         RawBufferVector rawCertChain;
 866
 867         for (auto &e : certChain) {
 868                 if (!e || e->empty()) {
 869                         LogError("Empty certificate");
 870                         return CKM_API_ERROR_INPUT_PARAM;
 871                 }
 872
 873                 rawCertChain.push_back(e->getDER());
 874         }
 875
 876         auto send = MessageBuffer::Serialize(msgId, rawCertChain);
 877
 878         int retCode = m_ocspConnection.processRequest(send.Pop(), recv);
 879
 880         if (CKM_API_SUCCESS != retCode)
 881                 return retCode;
 882
 883         int retMsgId;
 884         recv.Deserialize(retMsgId, retCode, ocspStatus);
 885
 886         if (msgId != retMsgId)
 887                 return CKM_API_ERROR_UNKNOWN;
 888
 889         return retCode;
 890
 891         EXCEPTION_GUARD_END
 892 }
 893
 894 int Manager::Impl::setPermission(const Alias &alias,
 895                                                                  const ClientId &accessor,
 896                                                                  PermissionMask permissionMask)
 897 {
 898         int msgId = ++m_counter;
 899
 900         EXCEPTION_GUARD_START_CPPAPI
 901
 902         MessageBuffer recv;
 903         AliasSupport helper(alias);
 904         auto send = MessageBuffer::Serialize(static_cast<int>
 905                                                                                  (LogicCommand::SET_PERMISSION),
 906                                                                                  msgId,
 907                                                                                  helper.getName(),
 908                                                                                  helper.getOwner(),
 909                                                                                  accessor,
 910                                                                                  permissionMask);
 911
 912         int retCode = m_storageConnection.processRequest(send.Pop(), recv);
 913
 914         if (CKM_API_SUCCESS != retCode)
 915                 return retCode;
 916
 917         int retMsgId;
 918         recv.Deserialize(retMsgId, retCode);
 919
 920         if (msgId != retMsgId)
 921                 return CKM_API_ERROR_UNKNOWN;
 922
 923         return retCode;
 924
 925         EXCEPTION_GUARD_END
 926 }
 927
 928 int Manager::Impl::crypt(EncryptionCommand command,
 929                                                  const CryptoAlgorithm &algo,
 930                                                  const Alias &keyAlias,
 931                                                  const Password &password,
 932                                                  const RawBuffer &input,
 933                                                  RawBuffer &output)
 934 {
 935         int msgId = ++m_counter;
 936
 937         EXCEPTION_GUARD_START_CPPAPI
 938
 939         MessageBuffer recv;
 940         AliasSupport helper(keyAlias);
 941         CryptoAlgorithmSerializable cas(algo);
 942         auto send = MessageBuffer::Serialize(static_cast<int>(command),
 943                                                                                  msgId,
 944                                                                                  cas,
 945                                                                                  helper.getName(),
 946                                                                                  helper.getOwner(),
 947                                                                                  password,
 948                                                                                  input);
 949
 950         int retCode = m_encryptionConnection.processRequest(send.Pop(), recv);
 951
 952         if (CKM_API_SUCCESS != retCode)
 953                 return retCode;
 954
 955         int retMsgId;
 956         recv.Deserialize(retMsgId, retCode, output);
 957
 958         if (msgId != retMsgId)
 959                 return CKM_API_ERROR_UNKNOWN;
 960
 961         return retCode;
 962
 963         EXCEPTION_GUARD_END
 964 }
 965
 966 int Manager::Impl::encrypt(const CryptoAlgorithm &algo,
 967                                                    const Alias &keyAlias,
 968                                                    const Password &password,
 969                                                    const RawBuffer &plain,
 970                                                    RawBuffer &encrypted)
 971 {
 972         return crypt(EncryptionCommand::ENCRYPT, algo, keyAlias, password, plain,
 973                                  encrypted);
 974 }
 975
 976 int Manager::Impl::decrypt(const CryptoAlgorithm &algo,
 977                                                    const Alias &keyAlias,
 978                                                    const Password &password,
 979                                                    const RawBuffer &encrypted,
 980                                                    RawBuffer &decrypted)
 981 {
 982         return crypt(EncryptionCommand::DECRYPT, algo, keyAlias, password, encrypted,
 983                                  decrypted);
 984 }
 985
 986 } // namespace CKM