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