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