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