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         return retMsgId != msgId ? CKM_API_ERROR_UNKNOWN : retCode;
 446 }
 447
 448 int Manager::Impl::getBinaryDataAliasVector(DataType dataType,
 449                 AliasVector &aliasVector)
 450 {
 451         EXCEPTION_GUARD_START_CPPAPI
 452         OwnerNameVector ownerNameVector;
 453         int retCode = getBinaryDataAliasVectorHelper(dataType, ownerNameVector);
 454
 455         if (retCode != CKM_API_SUCCESS)
 456                 return retCode;
 457
 458         for (const auto &it : ownerNameVector)
 459                 aliasVector.push_back(AliasSupport::merge(it.first, it.second));
 460
 461         return CKM_API_SUCCESS;
 462         EXCEPTION_GUARD_END
 463 }
 464
 465 int Manager::Impl::getBinaryDataAliasPwdVector(DataType dataType,
 466                 AliasPwdVector &aliasPwdVector)
 467 {
 468         EXCEPTION_GUARD_START_CPPAPI
 469         OwnerNameVector ownerNameVector;
 470         OwnerNameEncryptionStatusVector ownerNameEncryptionStatusVector;
 471         int retCode = getBinaryDataAliasVectorHelper(dataType, ownerNameVector);
 472
 473         if (retCode != CKM_API_SUCCESS)
 474                 return retCode;
 475
 476         for (const auto &it : ownerNameVector)
 477         {
 478                 Alias alias = AliasSupport::merge(std::get<0>(it), std::get<1>(it));
 479                 bool status;
 480                 retCode = getBinaryDataEncryptionStatus(dataType, alias, status);
 481
 482                 if (retCode != CKM_API_SUCCESS)
 483                         return retCode;
 484
 485                 aliasPwdVector.push_back(std::make_pair(alias, status));
 486         }
 487         return CKM_API_SUCCESS;
 488         EXCEPTION_GUARD_END
 489 }
 490
 491 int Manager::Impl::getKeyAliasVector(AliasVector &aliasVector)
 492 {
 493         // in fact datatype has no meaning here - if not certificate or binary data
 494         // then manager decides to list all between DB_KEY_FIRST and DB_KEY_LAST
 495         return getBinaryDataAliasVector(DataType::DB_KEY_LAST, aliasVector);
 496 }
 497
 498 int Manager::Impl::getCertificateAliasVector(AliasVector &aliasVector)
 499 {
 500         return getBinaryDataAliasVector(DataType::CERTIFICATE, aliasVector);
 501 }
 502
 503 int Manager::Impl::getDataAliasVector(AliasVector &aliasVector)
 504 {
 505         return getBinaryDataAliasVector(DataType::BINARY_DATA, aliasVector);
 506 }
 507
 508 int Manager::Impl::getKeyAliasPwdVector(AliasPwdVector &aliasPwdVector)
 509 {
 510         return getBinaryDataAliasPwdVector(DataType::DB_KEY_LAST, aliasPwdVector);
 511 }
 512
 513 int Manager::Impl::getKeyEncryptionStatus(const Alias &alias, bool &status)
 514 {
 515         return getBinaryDataEncryptionStatus(DataType::DB_KEY_LAST, alias, status);
 516 }
 517
 518 int Manager::Impl::getCertificateAliasPwdVector(AliasPwdVector &aliasPwdVector)
 519 {
 520         return getBinaryDataAliasPwdVector(DataType::CERTIFICATE, aliasPwdVector);
 521 }
 522
 523 int Manager::Impl::getCertificateEncryptionStatus(const Alias &alias, bool &status)
 524 {
 525         return getBinaryDataEncryptionStatus(DataType::CERTIFICATE, alias, status);
 526 }
 527
 528 int Manager::Impl::getDataAliasPwdVector(AliasPwdVector &aliasPwdVector)
 529 {
 530         return getBinaryDataAliasPwdVector(DataType::BINARY_DATA, aliasPwdVector);
 531 }
 532
 533 int Manager::Impl::getDataEncryptionStatus(const Alias &alias, bool &status)
 534 {
 535         return getBinaryDataEncryptionStatus(DataType::BINARY_DATA, alias, status);
 536 }
 537
 538 int Manager::Impl::createKeyPairRSA(
 539         const int size,
 540         const Alias &privateKeyAlias,
 541         const Alias &publicKeyAlias,
 542         const Policy &policyPrivateKey,
 543         const Policy &policyPublicKey)
 544 {
 545         return this->createKeyPair(CKM::KeyType::KEY_RSA_PUBLIC, size, privateKeyAlias,
 546                                                            publicKeyAlias, policyPrivateKey, policyPublicKey);
 547 }
 548
 549 int Manager::Impl::createKeyPairDSA(
 550         const int size,
 551         const Alias &privateKeyAlias,
 552         const Alias &publicKeyAlias,
 553         const Policy &policyPrivateKey,
 554         const Policy &policyPublicKey)
 555 {
 556         return this->createKeyPair(CKM::KeyType::KEY_DSA_PUBLIC, size, privateKeyAlias,
 557                                                            publicKeyAlias, policyPrivateKey, policyPublicKey);
 558 }
 559
 560 int Manager::Impl::createKeyPairECDSA(
 561         ElipticCurve type,
 562         const Alias &privateKeyAlias,
 563         const Alias &publicKeyAlias,
 564         const Policy &policyPrivateKey,
 565         const Policy &policyPublicKey)
 566 {
 567         return this->createKeyPair(CKM::KeyType::KEY_ECDSA_PUBLIC,
 568                                                            static_cast<int>(type), privateKeyAlias, publicKeyAlias, policyPrivateKey,
 569                                                            policyPublicKey);
 570 }
 571
 572 int Manager::Impl::createKeyAES(
 573         const int size,
 574         const Alias &keyAlias,
 575         const Policy &policyKey)
 576 {
 577         // proceed with sending request
 578         int msgId = ++m_counter;
 579
 580         EXCEPTION_GUARD_START_CPPAPI
 581
 582         MessageBuffer recv;
 583         AliasSupport aliasHelper(keyAlias);
 584         auto send = SerializeMessage(static_cast<int>(LogicCommand::CREATE_KEY_AES),
 585                                                                  msgId,
 586                                                                  static_cast<int>(size),
 587                                                                  PolicySerializable(policyKey),
 588                                                                  aliasHelper.getName(),
 589                                                                  aliasHelper.getOwner());
 590
 591         int retCode = m_storageConnection.processRequest(send, recv);
 592
 593         if (CKM_API_SUCCESS != retCode)
 594                 return retCode;
 595
 596         return deserialize(msgId, recv);
 597
 598         EXCEPTION_GUARD_END
 599 }
 600
 601
 602 int Manager::Impl::createKeyPair(
 603         const KeyType key_type,
 604         const int     additional_param,
 605         const Alias  &privateKeyAlias,
 606         const Alias  &publicKeyAlias,
 607         const Policy &policyPrivateKey,
 608         const Policy &policyPublicKey)
 609 {
 610         // input type check
 611         CryptoAlgorithm keyGenAlgorithm;
 612
 613         switch (key_type) {
 614         case KeyType::KEY_RSA_PUBLIC:
 615         case KeyType::KEY_RSA_PRIVATE:
 616                 keyGenAlgorithm.setParam(ParamName::ALGO_TYPE, AlgoType::RSA_GEN);
 617                 keyGenAlgorithm.setParam(ParamName::GEN_KEY_LEN, additional_param);
 618                 break;
 619
 620         case KeyType::KEY_DSA_PUBLIC:
 621         case KeyType::KEY_DSA_PRIVATE:
 622                 keyGenAlgorithm.setParam(ParamName::ALGO_TYPE, AlgoType::DSA_GEN);
 623                 keyGenAlgorithm.setParam(ParamName::GEN_KEY_LEN, additional_param);
 624                 break;
 625
 626         case KeyType::KEY_ECDSA_PUBLIC:
 627         case KeyType::KEY_ECDSA_PRIVATE:
 628                 keyGenAlgorithm.setParam(ParamName::ALGO_TYPE, AlgoType::ECDSA_GEN);
 629                 keyGenAlgorithm.setParam(ParamName::GEN_EC, additional_param);
 630                 break;
 631
 632         default:
 633                 return CKM_API_ERROR_INPUT_PARAM;
 634         }
 635
 636         // proceed with sending request
 637         int msgId = ++m_counter;
 638
 639         EXCEPTION_GUARD_START_CPPAPI
 640
 641         MessageBuffer recv;
 642         AliasSupport privateHelper(privateKeyAlias);
 643         AliasSupport publicHelper(publicKeyAlias);
 644         auto send = SerializeMessage(static_cast<int>(LogicCommand::CREATE_KEY_PAIR),
 645                                                                  msgId,
 646                                                                  CryptoAlgorithmSerializable(keyGenAlgorithm),
 647                                                                  PolicySerializable(policyPrivateKey),
 648                                                                  PolicySerializable(policyPublicKey),
 649                                                                  privateHelper.getName(),
 650                                                                  privateHelper.getOwner(),
 651                                                                  publicHelper.getName(),
 652                                                                  publicHelper.getOwner());
 653
 654         int retCode = m_storageConnection.processRequest(send, recv);
 655
 656         if (CKM_API_SUCCESS != retCode)
 657                 return retCode;
 658
 659         return deserialize(msgId, recv);
 660
 661         EXCEPTION_GUARD_END
 662 }
 663
 664 int Manager::Impl::getCertificateChain(
 665         const CertificateShPtr &certificate,
 666         const CertificateShPtrVector &untrustedCertificates,
 667         const CertificateShPtrVector &trustedCertificates,
 668         bool useTrustedSystemCertificates,
 669         CertificateShPtrVector &certificateChainVector)
 670 {
 671         RawBufferVector untrustedVector;
 672         RawBufferVector trustedVector;
 673
 674         if (!certificate || certificate->empty())
 675                 return CKM_API_ERROR_INPUT_PARAM;
 676
 677         for (auto &e : untrustedCertificates) {
 678                 if (!e || e->empty())
 679                         return CKM_API_ERROR_INPUT_PARAM;
 680                 untrustedVector.push_back(e->getDER());
 681         }
 682
 683         for (auto &e : trustedCertificates) {
 684                 if (!e || e->empty())
 685                         return CKM_API_ERROR_INPUT_PARAM;
 686                 trustedVector.push_back(e->getDER());
 687         }
 688
 689         return getCertChain(
 690                            m_storageConnection,
 691                            LogicCommand::GET_CHAIN_CERT,
 692                            ++m_counter,
 693                            certificate,
 694                            untrustedVector,
 695                            trustedVector,
 696                            useTrustedSystemCertificates,
 697                            certificateChainVector);
 698 }
 699
 700 int Manager::Impl::getCertificateChain(
 701         const CertificateShPtr &certificate,
 702         const AliasVector &untrustedCertificates,
 703         const AliasVector &trustedCertificates,
 704         bool useTrustedSystemCertificates,
 705         CertificateShPtrVector &certificateChainVector)
 706 {
 707         OwnerNameVector untrustedVector;
 708         OwnerNameVector trustedVector;
 709
 710         if (!certificate || certificate->empty())
 711                 return CKM_API_ERROR_INPUT_PARAM;
 712
 713         for (auto &e : untrustedCertificates) {
 714                 AliasSupport helper(e);
 715                 untrustedVector.push_back(std::make_pair(helper.getOwner(), helper.getName()));
 716         }
 717
 718         for (auto &e : trustedCertificates) {
 719                 AliasSupport helper(e);
 720                 trustedVector.push_back(std::make_pair(helper.getOwner(), helper.getName()));
 721         }
 722
 723         return getCertChain(
 724                            m_storageConnection,
 725                            LogicCommand::GET_CHAIN_ALIAS,
 726                            ++m_counter,
 727                            certificate,
 728                            untrustedVector,
 729                            trustedVector,
 730                            useTrustedSystemCertificates,
 731                            certificateChainVector);
 732 }
 733
 734 int Manager::Impl::createSignature(
 735         const Alias &privateKeyAlias,
 736         const Password &password,           // password for private_key
 737         const RawBuffer &message,
 738         const CryptoAlgorithm &cAlgorithm,
 739         RawBuffer &signature)
 740 {
 741         int msgId = ++m_counter;
 742
 743         EXCEPTION_GUARD_START_CPPAPI
 744
 745         MessageBuffer recv;
 746         AliasSupport helper(privateKeyAlias);
 747         auto send = SerializeMessage(static_cast<int>(LogicCommand::CREATE_SIGNATURE),
 748                                                                  msgId,
 749                                                                  helper.getName(),
 750                                                                  helper.getOwner(),
 751                                                                  password,
 752                                                                  message,
 753                                                                  CryptoAlgorithmSerializable(cAlgorithm));
 754
 755         int retCode = m_storageConnection.processRequest(send, recv);
 756
 757         if (CKM_API_SUCCESS != retCode)
 758                 return retCode;
 759
 760         return deserialize(msgId, recv, signature);
 761
 762         EXCEPTION_GUARD_END
 763 }
 764
 765 int Manager::Impl::verifySignature(
 766         const Alias &publicKeyOrCertAlias,
 767         const Password &password,           // password for public_key (optional)
 768         const RawBuffer &message,
 769         const RawBuffer &signature,
 770         const CryptoAlgorithm &cAlg)
 771 {
 772         int msgId = ++m_counter;
 773
 774         EXCEPTION_GUARD_START_CPPAPI
 775
 776         MessageBuffer recv;
 777         AliasSupport helper(publicKeyOrCertAlias);
 778         auto send = SerializeMessage(static_cast<int>(LogicCommand::VERIFY_SIGNATURE),
 779                                                                  msgId,
 780                                                                  helper.getName(),
 781                                                                  helper.getOwner(),
 782                                                                  password,
 783                                                                  message,
 784                                                                  signature,
 785                                                                  CryptoAlgorithmSerializable(cAlg));
 786
 787         int retCode = m_storageConnection.processRequest(send, recv);
 788
 789         if (CKM_API_SUCCESS != retCode)
 790                 return retCode;
 791
 792         return deserialize(msgId, recv);
 793
 794         EXCEPTION_GUARD_END
 795 }
 796
 797 int Manager::Impl::ocspCheck(const CertificateShPtrVector &certChain,
 798                                                          int &ocspStatus)
 799 {
 800         EXCEPTION_GUARD_START_CPPAPI
 801
 802         int msgId = ++m_counter;
 803         MessageBuffer recv;
 804
 805         RawBufferVector rawCertChain;
 806
 807         for (auto &e : certChain) {
 808                 if (!e || e->empty()) {
 809                         LogError("Empty certificate");
 810                         return CKM_API_ERROR_INPUT_PARAM;
 811                 }
 812
 813                 rawCertChain.push_back(e->getDER());
 814         }
 815
 816         auto send = SerializeMessage(msgId, rawCertChain);
 817
 818         int retCode = m_ocspConnection.processRequest(send, recv);
 819
 820         if (CKM_API_SUCCESS != retCode)
 821                 return retCode;
 822
 823         return deserialize(msgId, recv, ocspStatus);
 824
 825         EXCEPTION_GUARD_END
 826 }
 827
 828 int Manager::Impl::setPermission(const Alias &alias,
 829                                                                  const ClientId &accessor,
 830                                                                  PermissionMask permissionMask)
 831 {
 832         int msgId = ++m_counter;
 833
 834         EXCEPTION_GUARD_START_CPPAPI
 835
 836         MessageBuffer recv;
 837         AliasSupport helper(alias);
 838         auto send = SerializeMessage(static_cast<int>(LogicCommand::SET_PERMISSION),
 839                                                                  msgId,
 840                                                                  helper.getName(),
 841                                                                  helper.getOwner(),
 842                                                                  accessor,
 843                                                                  permissionMask);
 844
 845         int retCode = m_storageConnection.processRequest(send, recv);
 846
 847         if (CKM_API_SUCCESS != retCode)
 848                 return retCode;
 849
 850         return deserialize(msgId, recv);
 851
 852         EXCEPTION_GUARD_END
 853 }
 854
 855 int Manager::Impl::crypt(EncryptionCommand command,
 856                                                  const CryptoAlgorithm &algo,
 857                                                  const Alias &keyAlias,
 858                                                  const Password &password,
 859                                                  const RawBuffer &input,
 860                                                  RawBuffer &output)
 861 {
 862         int msgId = ++m_counter;
 863
 864         EXCEPTION_GUARD_START_CPPAPI
 865
 866         MessageBuffer recv;
 867         AliasSupport helper(keyAlias);
 868         CryptoAlgorithmSerializable cas(algo);
 869         auto send = SerializeMessage(static_cast<int>(command),
 870                                                                  msgId,
 871                                                                  cas,
 872                                                                  helper.getName(),
 873                                                                  helper.getOwner(),
 874                                                                  password,
 875                                                                  input);
 876
 877         int retCode = m_encryptionConnection.processRequest(send, recv);
 878
 879         if (CKM_API_SUCCESS != retCode)
 880                 return retCode;
 881
 882         return deserialize(msgId, recv, output);
 883
 884         EXCEPTION_GUARD_END
 885 }
 886
 887 int Manager::Impl::encrypt(const CryptoAlgorithm &algo,
 888                                                    const Alias &keyAlias,
 889                                                    const Password &password,
 890                                                    const RawBuffer &plain,
 891                                                    RawBuffer &encrypted)
 892 {
 893         return crypt(EncryptionCommand::ENCRYPT, algo, keyAlias, password, plain,
 894                                  encrypted);
 895 }
 896
 897 int Manager::Impl::decrypt(const CryptoAlgorithm &algo,
 898                                                    const Alias &keyAlias,
 899                                                    const Password &password,
 900                                                    const RawBuffer &encrypted,
 901                                                    RawBuffer &decrypted)
 902 {
 903         return crypt(EncryptionCommand::DECRYPT, algo, keyAlias, password, encrypted,
 904                                  decrypted);
 905 }
 906
 907 } // namespace CKM