1 /* Copyright (c) 2014-2020 Samsung Electronics Co., Ltd. All rights reserved
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
7 * http://www.apache.org/licenses/LICENSE-2.0
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
16 * @file client-manager-impl.cpp
17 * @author Bartlomiej Grzelewski (b.grzelewski@samsung.com)
19 * @brief Manager implementation.
21 #include <openssl/evp.h>
23 #include <dpl/serialization.h>
24 #include <dpl/log/log.h>
26 #include <client-manager-impl.h>
27 #include <client-common.h>
28 #include <exception.h>
29 #include <message-buffer.h>
30 #include <protocols.h>
32 #include <key-aes-impl.h>
33 #include <certificate-impl.h>
39 int deserializeResponse(const int msgId, MessageBuffer &recv, T&&...t)
41 int retMsgId, retCode;
42 recv.Deserialize(retMsgId, retCode, std::forward<T>(t)...);
43 return msgId != retMsgId ? CKM_API_ERROR_UNKNOWN : retCode;
48 ServiceConnection &serviceConnection,
51 const CertificateShPtr &certificate,
52 const T &untrustedVector,
53 const T &trustedVector,
54 bool useTrustedSystemCertificates,
55 CertificateShPtrVector &certificateChainVector)
57 EXCEPTION_GUARD_START_CPPAPI
59 Manager::Impl::Request rq(impl, command, serviceConnection,
60 certificate->getDER(), untrustedVector, trustedVector, useTrustedSystemCertificates);
64 RawBufferVector rawBufferVector;
65 int retCode = rq.deserialize(rawBufferVector);
67 if (retCode != CKM_API_SUCCESS)
70 for (auto &e : rawBufferVector) {
71 CertificateShPtr cert(new CertificateImpl(e, DataFormat::FORM_DER));
74 return CKM_API_ERROR_BAD_RESPONSE;
76 certificateChainVector.push_back(std::move(cert));
85 int doRequest(MessageBuffer &recv, CKM::ServiceConnection &conn, T&&...t)
87 return conn.processRequest(SerializeMessage(std::forward<T>(t)...), recv);
93 : m_storageConnection(SERVICE_SOCKET_CKM_STORAGE),
94 m_ocspConnection(SERVICE_SOCKET_OCSP),
95 m_encryptionConnection(SERVICE_SOCKET_ENCRYPTION)
99 template <class Cmd, class...T>
100 Manager::Impl::Request::Request(Manager::Impl &impl, Cmd cmd, CKM::ServiceConnection &conn, T&&...t)
102 static_assert(sizeof cmd <= sizeof(int));
103 const auto msgId = m_msgId = ++impl.m_counter;
104 m_retCode = doRequest(m_recv, conn, cmd, msgId, std::forward<T>(t)...);
107 Manager::Impl::Request::operator bool() const {
108 return CKM_API_SUCCESS == m_retCode;
111 int Manager::Impl::Request::err() const {
117 int Manager::Impl::Request::deserialize(T&&...t)
120 return deserializeResponse(m_msgId, m_recv, std::forward<T>(t)...);
124 int Manager::Impl::Request::maybeDeserialize(T&&...t)
126 return *this ? deserialize(std::forward<T>(t)...) : err();
129 int Manager::Impl::saveBinaryData(
132 const RawBuffer &rawData,
133 const Policy &policy)
135 EXCEPTION_GUARD_START_CPPAPI
137 if (alias.empty() || rawData.empty())
138 return CKM_API_ERROR_INPUT_PARAM;
140 AliasSupport helper(alias);
143 return Request(*this, LogicCommand::SAVE, m_storageConnection,
144 dataType, helper.getName(), helper.getOwner(), rawData, PolicySerializable(policy)
145 ).maybeDeserialize(opType);
150 int Manager::Impl::saveKey(const Alias &alias, const KeyShPtr &key,
151 const Policy &policy)
153 if (key.get() == NULL || key->empty())
154 return CKM_API_ERROR_INPUT_PARAM;
156 return saveBinaryData(alias, DataType(key->getType()), key->getDER(), policy);
157 } catch (const Exc::Exception &e) {
158 LogError("Exception: " << e.what());
163 int Manager::Impl::saveCertificate(
165 const CertificateShPtr &cert,
166 const Policy &policy)
168 return cert.get() == NULL || cert->empty()
169 ? CKM_API_ERROR_INPUT_PARAM
170 : saveBinaryData(alias, DataType::CERTIFICATE, cert->getDER(), policy);
173 int Manager::Impl::saveData(const Alias &alias, const RawBuffer &rawData,
174 const Policy &policy)
176 return saveBinaryData(alias, DataType::BINARY_DATA, rawData, policy);
180 int Manager::Impl::savePKCS12(
182 const PKCS12ShPtr &pkcs,
183 const Policy &keyPolicy,
184 const Policy &certPolicy)
186 if (alias.empty() || pkcs.get() == NULL)
187 return CKM_API_ERROR_INPUT_PARAM;
189 EXCEPTION_GUARD_START_CPPAPI
191 AliasSupport helper(alias);
193 return Request(*this, LogicCommand::SAVE_PKCS12, m_storageConnection,
194 helper.getName(), helper.getOwner(), PKCS12Serializable(*pkcs.get()),
195 PolicySerializable(keyPolicy), PolicySerializable(certPolicy)
196 ).maybeDeserialize();
201 int Manager::Impl::getPKCS12(const Alias &alias, PKCS12ShPtr &pkcs)
203 return getPKCS12(alias, Password(), Password(), pkcs);
206 int Manager::Impl::getPKCS12(const Alias &alias, const Password &keyPass,
207 const Password &certPass, PKCS12ShPtr &pkcs)
210 return CKM_API_ERROR_INPUT_PARAM;
212 EXCEPTION_GUARD_START_CPPAPI
214 AliasSupport helper(alias);
216 int msgId = ++m_counter;
219 int retCode = doRequest(recv, m_storageConnection, LogicCommand::GET_PKCS12, msgId,
220 helper.getName(), helper.getOwner(), keyPass, certPass);
222 if (CKM_API_SUCCESS != retCode)
226 PKCS12Serializable gotPkcs;
227 recv.Deserialize(retMsgId, retCode, gotPkcs);
229 if (retMsgId != msgId)
230 return CKM_API_ERROR_UNKNOWN;
232 pkcs = std::make_shared<PKCS12Impl>(std::move(gotPkcs));
240 int Manager::Impl::removeAlias(const Alias &alias)
243 return CKM_API_ERROR_INPUT_PARAM;
245 EXCEPTION_GUARD_START_CPPAPI
247 AliasSupport helper(alias);
249 return Request(*this, LogicCommand::REMOVE, m_storageConnection,
250 helper.getName(), helper.getOwner()
251 ).maybeDeserialize();
256 int Manager::Impl::getBinaryData(
258 DataType sendDataType,
259 const Password &password,
260 DataType &recvDataType,
264 return CKM_API_ERROR_INPUT_PARAM;
266 EXCEPTION_GUARD_START_CPPAPI
268 AliasSupport helper(alias);
270 return Request(*this, LogicCommand::GET, m_storageConnection,
271 sendDataType, helper.getName(), helper.getOwner(), password
272 ).maybeDeserialize(recvDataType, rawData);
277 int Manager::Impl::getBinaryDataEncryptionStatus(const DataType sendDataType,
278 const Alias &alias, bool &status)
282 return CKM_API_ERROR_INPUT_PARAM;
284 EXCEPTION_GUARD_START_CPPAPI
286 AliasSupport helper(alias);
287 DataType tmpDataType;
289 int retCode = Request(*this, LogicCommand::GET_PROTECTION_STATUS, m_storageConnection,
290 sendDataType, helper.getName(), helper.getOwner()
291 ).maybeDeserialize(tmpDataType, status);
293 if (retCode != CKM_API_SUCCESS)
301 int Manager::Impl::getKey(const Alias &alias, const Password &password,
304 DataType recvDataType;
307 int retCode = getBinaryData(alias, DataType::KEY_RSA_PUBLIC, password, recvDataType, rawData);
309 if (retCode != CKM_API_SUCCESS)
312 KeyShPtr keyParsed = recvDataType.isSymmetricKey() ? Key::createAES(rawData) : Key::create(rawData);
315 LogDebug("Key empty - failed to parse!");
316 return CKM_API_ERROR_BAD_RESPONSE;
321 return CKM_API_SUCCESS;
324 int Manager::Impl::getCertificate(const Alias &alias, const Password &password,
325 CertificateShPtr &cert)
327 DataType recvDataType;
330 int retCode = getBinaryData(alias, DataType::CERTIFICATE, password, recvDataType, rawData);
332 if (retCode != CKM_API_SUCCESS)
335 if (!recvDataType.isCertificate())
336 return CKM_API_ERROR_BAD_RESPONSE;
338 CertificateShPtr certParsed(new CertificateImpl(rawData, DataFormat::FORM_DER));
340 if (certParsed->empty())
341 return CKM_API_ERROR_BAD_RESPONSE;
343 cert = std::move(certParsed);
345 return CKM_API_SUCCESS;
348 int Manager::Impl::getData(const Alias &alias, const Password &password,
351 DataType recvDataType = DataType::BINARY_DATA;
353 int retCode = getBinaryData(alias, DataType::BINARY_DATA, password, recvDataType, rawData);
355 if (retCode != CKM_API_SUCCESS)
358 return recvDataType.isBinaryData() ? CKM_API_SUCCESS : CKM_API_ERROR_BAD_RESPONSE;
361 int Manager::Impl::getAliasInfoVectorHelper(DataType dataType, AliasInfoVector &aliasInfoVector)
363 DataType tmpDataType;
364 AliasInfoSerializableVector aisv(aliasInfoVector);
365 return Request(*this,
366 LogicCommand::GET_LIST,
368 dataType).maybeDeserialize(tmpDataType, aisv);
371 int Manager::Impl::getAliasVectorHelper(DataType dataType, AliasVector &aliasVector)
373 EXCEPTION_GUARD_START_CPPAPI
374 AliasInfoVector aliasInfoVector;
375 int retCode = getAliasInfoVectorHelper(dataType, aliasInfoVector);
377 if (retCode != CKM_API_SUCCESS)
380 for (const auto &it : aliasInfoVector)
381 aliasVector.push_back(it.alias);
383 return CKM_API_SUCCESS;
387 int Manager::Impl::getKeyAliasVector(AliasVector &aliasVector)
389 // in fact datatype has no meaning here - if not certificate or binary data
390 // then manager decides to list all between DB_KEY_FIRST and DB_KEY_LAST
391 return getAliasVectorHelper(DataType::DB_KEY_LAST, aliasVector);
394 int Manager::Impl::getCertificateAliasVector(AliasVector &aliasVector)
396 return getAliasVectorHelper(DataType::CERTIFICATE, aliasVector);
399 int Manager::Impl::getDataAliasVector(AliasVector &aliasVector)
401 return getAliasVectorHelper(DataType::BINARY_DATA, aliasVector);
404 int Manager::Impl::getKeyAliasInfoVector(AliasInfoVector &aliasInfoVector)
406 EXCEPTION_GUARD_START_CPPAPI
407 return getAliasInfoVectorHelper(DataType::DB_KEY_LAST, aliasInfoVector);
411 int Manager::Impl::getKeyEncryptionStatus(const Alias &alias, bool &status)
413 return getBinaryDataEncryptionStatus(DataType::DB_KEY_LAST, alias, status);
416 int Manager::Impl::getCertificateAliasInfoVector(AliasInfoVector &aliasInfoVector)
418 EXCEPTION_GUARD_START_CPPAPI
419 return getAliasInfoVectorHelper(DataType::CERTIFICATE, aliasInfoVector);
423 int Manager::Impl::getCertificateEncryptionStatus(const Alias &alias, bool &status)
425 return getBinaryDataEncryptionStatus(DataType::CERTIFICATE, alias, status);
428 int Manager::Impl::getDataAliasInfoVector(AliasInfoVector &aliasInfoVector)
430 EXCEPTION_GUARD_START_CPPAPI
431 return getAliasInfoVectorHelper(DataType::BINARY_DATA, aliasInfoVector);
435 int Manager::Impl::getDataEncryptionStatus(const Alias &alias, bool &status)
437 return getBinaryDataEncryptionStatus(DataType::BINARY_DATA, alias, status);
440 int Manager::Impl::createKeyPairRSA(
442 const Alias &privateKeyAlias,
443 const Alias &publicKeyAlias,
444 const Policy &policyPrivateKey,
445 const Policy &policyPublicKey)
447 return this->createKeyPair(CKM::KeyType::KEY_RSA_PUBLIC, size, privateKeyAlias,
448 publicKeyAlias, policyPrivateKey, policyPublicKey);
451 int Manager::Impl::createKeyPairDSA(
453 const Alias &privateKeyAlias,
454 const Alias &publicKeyAlias,
455 const Policy &policyPrivateKey,
456 const Policy &policyPublicKey)
458 return this->createKeyPair(CKM::KeyType::KEY_DSA_PUBLIC, size, privateKeyAlias,
459 publicKeyAlias, policyPrivateKey, policyPublicKey);
462 int Manager::Impl::createKeyPairECDSA(
464 const Alias &privateKeyAlias,
465 const Alias &publicKeyAlias,
466 const Policy &policyPrivateKey,
467 const Policy &policyPublicKey)
469 return this->createKeyPair(CKM::KeyType::KEY_ECDSA_PUBLIC,
470 static_cast<int>(type), privateKeyAlias, publicKeyAlias,
471 policyPrivateKey, policyPublicKey);
474 int Manager::Impl::createKeyAES(
476 const Alias &keyAlias,
477 const Policy &policyKey)
479 EXCEPTION_GUARD_START_CPPAPI
481 AliasSupport aliasHelper(keyAlias);
483 return Request(*this, LogicCommand::CREATE_KEY_AES, m_storageConnection,
484 size, PolicySerializable(policyKey),
485 aliasHelper.getName(), aliasHelper.getOwner()
486 ).maybeDeserialize();
492 int Manager::Impl::createKeyPair(
493 const KeyType key_type,
494 const int additional_param,
495 const Alias &privateKeyAlias,
496 const Alias &publicKeyAlias,
497 const Policy &policyPrivateKey,
498 const Policy &policyPublicKey)
501 CryptoAlgorithm keyGenAlgorithm;
504 case KeyType::KEY_RSA_PUBLIC:
505 case KeyType::KEY_RSA_PRIVATE:
506 keyGenAlgorithm.setParam(ParamName::ALGO_TYPE, AlgoType::RSA_GEN);
507 keyGenAlgorithm.setParam(ParamName::GEN_KEY_LEN, additional_param);
510 case KeyType::KEY_DSA_PUBLIC:
511 case KeyType::KEY_DSA_PRIVATE:
512 keyGenAlgorithm.setParam(ParamName::ALGO_TYPE, AlgoType::DSA_GEN);
513 keyGenAlgorithm.setParam(ParamName::GEN_KEY_LEN, additional_param);
516 case KeyType::KEY_ECDSA_PUBLIC:
517 case KeyType::KEY_ECDSA_PRIVATE:
518 keyGenAlgorithm.setParam(ParamName::ALGO_TYPE, AlgoType::ECDSA_GEN);
519 keyGenAlgorithm.setParam(ParamName::GEN_EC, additional_param);
523 return CKM_API_ERROR_INPUT_PARAM;
526 EXCEPTION_GUARD_START_CPPAPI
528 AliasSupport privateHelper(privateKeyAlias);
529 AliasSupport publicHelper(publicKeyAlias);
531 return Request(*this, LogicCommand::CREATE_KEY_PAIR, m_storageConnection,
532 CryptoAlgorithmSerializable(keyGenAlgorithm),
533 PolicySerializable(policyPrivateKey),
534 PolicySerializable(policyPublicKey),
535 privateHelper.getName(), privateHelper.getOwner(),
536 publicHelper.getName(), publicHelper.getOwner()
537 ).maybeDeserialize();
542 int Manager::Impl::getCertificateChain(
543 const CertificateShPtr &certificate,
544 const CertificateShPtrVector &untrustedCertificates,
545 const CertificateShPtrVector &trustedCertificates,
546 bool useTrustedSystemCertificates,
547 CertificateShPtrVector &certificateChainVector)
549 RawBufferVector untrustedVector;
550 RawBufferVector trustedVector;
552 if (!certificate || certificate->empty())
553 return CKM_API_ERROR_INPUT_PARAM;
555 for (auto &e : untrustedCertificates) {
556 if (!e || e->empty())
557 return CKM_API_ERROR_INPUT_PARAM;
558 untrustedVector.push_back(e->getDER());
561 for (auto &e : trustedCertificates) {
562 if (!e || e->empty())
563 return CKM_API_ERROR_INPUT_PARAM;
564 trustedVector.push_back(e->getDER());
567 return getCertChain(m_storageConnection, LogicCommand::GET_CHAIN_CERT, *this,
568 certificate, untrustedVector, trustedVector,
569 useTrustedSystemCertificates, certificateChainVector);
572 int Manager::Impl::getCertificateChain(
573 const CertificateShPtr &certificate,
574 const AliasVector &untrustedCertificates,
575 const AliasVector &trustedCertificates,
576 bool useTrustedSystemCertificates,
577 CertificateShPtrVector &certificateChainVector)
579 OwnerNameVector untrustedVector;
580 OwnerNameVector trustedVector;
582 if (!certificate || certificate->empty())
583 return CKM_API_ERROR_INPUT_PARAM;
585 for (auto &e : untrustedCertificates) {
586 AliasSupport helper(e);
587 untrustedVector.push_back(std::make_pair(helper.getOwner(), helper.getName()));
590 for (auto &e : trustedCertificates) {
591 AliasSupport helper(e);
592 trustedVector.push_back(std::make_pair(helper.getOwner(), helper.getName()));
595 return getCertChain(m_storageConnection, LogicCommand::GET_CHAIN_ALIAS, *this,
596 certificate, untrustedVector, trustedVector,
597 useTrustedSystemCertificates, certificateChainVector);
600 int Manager::Impl::createSignature(
601 const Alias &privateKeyAlias,
602 const Password &password, // password for private_key
603 const RawBuffer &message,
604 const CryptoAlgorithm &cAlgorithm,
605 RawBuffer &signature)
607 EXCEPTION_GUARD_START_CPPAPI
609 AliasSupport helper(privateKeyAlias);
611 return Request(*this, LogicCommand::CREATE_SIGNATURE, m_storageConnection,
612 helper.getName(), helper.getOwner(), password, message,
613 CryptoAlgorithmSerializable(cAlgorithm)
614 ).maybeDeserialize(signature);
619 int Manager::Impl::verifySignature(
620 const Alias &publicKeyOrCertAlias,
621 const Password &password, // password for public_key (optional)
622 const RawBuffer &message,
623 const RawBuffer &signature,
624 const CryptoAlgorithm &cAlg)
626 EXCEPTION_GUARD_START_CPPAPI
628 AliasSupport helper(publicKeyOrCertAlias);
630 return Request(*this, LogicCommand::VERIFY_SIGNATURE, m_storageConnection,
631 helper.getName(), helper.getOwner(), password, message, signature,
632 CryptoAlgorithmSerializable(cAlg)
633 ).maybeDeserialize();
638 int Manager::Impl::ocspCheck(const CertificateShPtrVector &certChain,
641 EXCEPTION_GUARD_START_CPPAPI
643 int msgId = ++m_counter;
646 RawBufferVector rawCertChain;
648 for (auto &e : certChain) {
649 if (!e || e->empty()) {
650 LogError("Empty certificate");
651 return CKM_API_ERROR_INPUT_PARAM;
654 rawCertChain.push_back(e->getDER());
657 int retCode = doRequest(recv, m_ocspConnection, msgId, rawCertChain);
659 if (CKM_API_SUCCESS != retCode)
662 return deserializeResponse(msgId, recv, ocspStatus);
667 int Manager::Impl::setPermission(const Alias &alias,
668 const ClientId &accessor,
669 PermissionMask permissionMask)
671 EXCEPTION_GUARD_START_CPPAPI
673 AliasSupport helper(alias);
675 return Request(*this, LogicCommand::SET_PERMISSION, m_storageConnection,
676 helper.getName(), helper.getOwner(), accessor, permissionMask
677 ).maybeDeserialize();
682 int Manager::Impl::crypt(EncryptionCommand command,
683 const CryptoAlgorithm &algo,
684 const Alias &keyAlias,
685 const Password &password,
686 const RawBuffer &input,
689 EXCEPTION_GUARD_START_CPPAPI
691 AliasSupport helper(keyAlias);
692 CryptoAlgorithmSerializable cas(algo);
694 return Request(*this, command, m_encryptionConnection,
695 cas, helper.getName(), helper.getOwner(), password, input
696 ).maybeDeserialize(output);
701 int Manager::Impl::encrypt(const CryptoAlgorithm &algo,
702 const Alias &keyAlias,
703 const Password &password,
704 const RawBuffer &plain,
705 RawBuffer &encrypted)
707 return crypt(EncryptionCommand::ENCRYPT, algo, keyAlias, password, plain,
711 int Manager::Impl::decrypt(const CryptoAlgorithm &algo,
712 const Alias &keyAlias,
713 const Password &password,
714 const RawBuffer &encrypted,
715 RawBuffer &decrypted)
717 return crypt(EncryptionCommand::DECRYPT, algo, keyAlias, password, encrypted,
721 int Manager::Impl::deriveKey(const CryptoAlgorithm &algo,
722 const Alias &secretAlias,
723 const Password &secretPassword,
724 const Alias &newKeyAlias,
725 const Policy &newKeyPolicy)
727 EXCEPTION_GUARD_START_CPPAPI
729 AliasSupport secret(secretAlias);
730 AliasSupport newKey(newKeyAlias);
731 CryptoAlgorithmSerializable cas(algo);
733 return Request(*this, LogicCommand::DERIVE, m_storageConnection,
734 cas, secret.getName(), secret.getOwner(), secretPassword,
735 newKey.getName(), newKey.getOwner(), PolicySerializable(newKeyPolicy)
736 ).maybeDeserialize();
741 int Manager::Impl::importWrappedKey(const CryptoAlgorithm ¶ms,
742 const Alias &wrappingKeyAlias,
743 const Password &wrappingKeyPassword,
745 const RawBuffer &wrappedKey,
746 const KeyType keyType,
747 const Policy &policy)
749 EXCEPTION_GUARD_START_CPPAPI
751 if (keyType == KeyType::KEY_NONE)
752 return CKM_API_ERROR_INPUT_PARAM;
754 AliasSupport wrapping_helper(wrappingKeyAlias);
755 AliasSupport helper(alias);
757 return Request(*this,
758 LogicCommand::IMPORT_WRAPPED_KEY,
760 CryptoAlgorithmSerializable(params),
761 wrapping_helper.getName(),
762 wrapping_helper.getOwner(),
768 PolicySerializable(policy)
769 ).maybeDeserialize();
774 int Manager::Impl::exportWrappedKey(const CryptoAlgorithm ¶ms,
775 const Alias &wrappingKeyAlias,
776 const Password &wrappingKeyPassword,
778 const Password &password,
780 RawBuffer &wrappedKey)
782 EXCEPTION_GUARD_START_CPPAPI
784 AliasSupport wrapping_helper(wrappingKeyAlias);
785 AliasSupport helper(alias);
786 DataType dataTypeKey;
788 int retCode = Request(*this,
789 LogicCommand::EXPORT_WRAPPED_KEY,
791 CryptoAlgorithmSerializable(params),
792 wrapping_helper.getName(),
793 wrapping_helper.getOwner(),
798 ).maybeDeserialize(dataTypeKey, wrappedKey);
800 if (retCode != CKM_API_SUCCESS)
803 if (dataTypeKey.isSymmetricKey()) {
804 keyType = KeyType::KEY_AES;
805 } else if (dataTypeKey.isKeyPrivate()) {
806 keyType = KeyType::KEY_RSA_PRIVATE;
808 return CKM_API_ERROR_INVALID_FORMAT;
816 int Manager::Impl::initializeCipher(
817 const CryptoAlgorithm ¶ms,
818 const Alias &keyAlias,
819 const Password &keyPassword,
823 EXCEPTION_GUARD_START_CPPAPI
825 AliasSupport helper(keyAlias);
827 return Request(*this,
828 EncryptionCommand::INITIALIZE_CIPHER,
829 m_encryptionConnection,
831 CryptoAlgorithmSerializable(params),
836 ).maybeDeserialize(requestId);
841 int Manager::Impl::updateCipher(int requestId, const RawBuffer &in, RawBuffer &out)
843 EXCEPTION_GUARD_START_CPPAPI
845 return Request(*this,
846 EncryptionCommand::UPDATE_CIPHER,
847 m_encryptionConnection,
850 ).maybeDeserialize(out);
855 int Manager::Impl::finalizeCipher(int requestId, const RawBuffer &in, RawBuffer &out)
857 EXCEPTION_GUARD_START_CPPAPI
859 return Request(*this,
860 EncryptionCommand::FINALIZE_CIPHER,
861 m_encryptionConnection,
864 ).maybeDeserialize(out);
869 int Manager::Impl::getBackendInfo(BackendId backend, BackendInfo& info)
871 EXCEPTION_GUARD_START_CPPAPI
873 BackendInfoSerializable bis(info);
874 return Request(*this,
875 LogicCommand::GET_BACKEND_INFO,
878 ).maybeDeserialize(bis);