src/manager/client/client-manager-impl.cpp

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