1 /* Copyright (c) 2000 - 2013 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 <dpl/serialization.h>
22 #include <dpl/log/log.h>
24 #include <client-manager-impl.h>
25 #include <client-common.h>
26 #include <message-buffer.h>
27 #include <protocols.h>
31 int Manager::ManagerImpl::saveBinaryData(
34 const RawBuffer &rawData,
39 return try_catch([&] {
40 if (alias.empty() || rawData.empty())
41 return CKM_API_ERROR_INPUT_PARAM;
43 MessageBuffer send, recv;
44 Serialization::Serialize(send, static_cast<int>(LogicCommand::SAVE));
45 Serialization::Serialize(send, m_counter);
46 Serialization::Serialize(send, static_cast<int>(dataType));
47 Serialization::Serialize(send, alias);
48 Serialization::Serialize(send, rawData);
49 Serialization::Serialize(send, PolicySerializable(policy));
51 int retCode = sendToServer(
52 SERVICE_SOCKET_CKM_STORAGE,
56 if (CKM_API_SUCCESS != retCode) {
63 Deserialization::Deserialize(recv, command);
64 Deserialization::Deserialize(recv, counter);
65 Deserialization::Deserialize(recv, retCode);
66 Deserialization::Deserialize(recv, opType);
68 if (counter != m_counter) {
69 return CKM_API_ERROR_UNKNOWN;
76 int Manager::ManagerImpl::saveKey(const Alias &alias, const Key &key, const Policy &policy) {
78 return CKM_API_ERROR_INPUT_PARAM;
79 return saveBinaryData(alias, toDBDataType(key.getType()), key.getDER(), policy);
82 int Manager::ManagerImpl::saveCertificate(
84 const Certificate &cert,
87 return saveBinaryData(alias, DBDataType::CERTIFICATE, cert.getDER(), policy);
90 int Manager::ManagerImpl::saveData(const Alias &alias, const RawBuffer &rawData, const Policy &policy) {
91 if (!policy.extractable)
92 return CKM_API_ERROR_INPUT_PARAM;
93 return saveBinaryData(alias, DBDataType::BINARY_DATA, rawData, policy);
96 int Manager::ManagerImpl::removeBinaryData(const Alias &alias, DBDataType dataType)
98 return try_catch([&] {
100 return CKM_API_ERROR_INPUT_PARAM;
102 MessageBuffer send, recv;
103 Serialization::Serialize(send, static_cast<int>(LogicCommand::REMOVE));
104 Serialization::Serialize(send, m_counter);
105 Serialization::Serialize(send, static_cast<int>(dataType));
106 Serialization::Serialize(send, alias);
108 int retCode = sendToServer(
109 SERVICE_SOCKET_CKM_STORAGE,
113 if (CKM_API_SUCCESS != retCode) {
120 Deserialization::Deserialize(recv, command);
121 Deserialization::Deserialize(recv, counter);
122 Deserialization::Deserialize(recv, retCode);
123 Deserialization::Deserialize(recv, opType);
125 if (counter != m_counter) {
126 return CKM_API_ERROR_UNKNOWN;
133 int Manager::ManagerImpl::removeKey(const Alias &alias) {
134 return removeBinaryData(alias, DBDataType::KEY_RSA_PUBLIC);
137 int Manager::ManagerImpl::removeCertificate(const Alias &alias) {
138 return removeBinaryData(alias, DBDataType::CERTIFICATE);
141 int Manager::ManagerImpl::removeData(const Alias &alias) {
142 return removeBinaryData(alias, DBDataType::BINARY_DATA);
145 int Manager::ManagerImpl::getBinaryData(
147 DBDataType sendDataType,
148 const std::string &password,
149 DBDataType &recvDataType,
152 return try_catch([&] {
154 return CKM_API_ERROR_INPUT_PARAM;
156 MessageBuffer send, recv;
157 Serialization::Serialize(send, static_cast<int>(LogicCommand::GET));
158 Serialization::Serialize(send, m_counter);
159 Serialization::Serialize(send, static_cast<int>(sendDataType));
160 Serialization::Serialize(send, alias);
161 Serialization::Serialize(send, password);
163 int retCode = sendToServer(
164 SERVICE_SOCKET_CKM_STORAGE,
168 if (CKM_API_SUCCESS != retCode) {
175 Deserialization::Deserialize(recv, command);
176 Deserialization::Deserialize(recv, counter);
177 Deserialization::Deserialize(recv, retCode);
178 Deserialization::Deserialize(recv, tmpDataType);
179 Deserialization::Deserialize(recv, rawData);
180 recvDataType = static_cast<DBDataType>(tmpDataType);
182 if (counter != m_counter) {
183 return CKM_API_ERROR_UNKNOWN;
190 int Manager::ManagerImpl::getKey(const Alias &alias, const std::string &password, Key &key) {
191 DBDataType recvDataType;
194 int retCode = getBinaryData(
196 DBDataType::KEY_RSA_PUBLIC,
201 if (retCode != CKM_API_SUCCESS)
204 Key keyParsed(rawData);
206 if (keyParsed.empty()) {
207 LogDebug("Key empty - failed to parse!");
208 return CKM_API_ERROR_BAD_RESPONSE;
213 return CKM_API_SUCCESS;
216 int Manager::ManagerImpl::getCertificate(const Alias &alias, const std::string &password, Certificate &cert)
218 DBDataType recvDataType;
221 int retCode = getBinaryData(
223 DBDataType::CERTIFICATE,
228 if (retCode != CKM_API_SUCCESS)
231 if (recvDataType != DBDataType::CERTIFICATE)
232 return CKM_API_ERROR_BAD_RESPONSE;
234 Certificate certParsed(rawData, DataFormat::FORM_DER);
236 if (certParsed.empty())
237 return CKM_API_ERROR_BAD_RESPONSE;
241 return CKM_API_SUCCESS;
244 int Manager::ManagerImpl::getData(const Alias &alias, const std::string &password, RawBuffer &rawData)
246 DBDataType recvDataType;
248 int retCode = getBinaryData(
250 DBDataType::BINARY_DATA,
255 if (retCode != CKM_API_SUCCESS)
258 if (recvDataType != DBDataType::BINARY_DATA)
259 return CKM_API_ERROR_BAD_RESPONSE;
261 return CKM_API_SUCCESS;
264 int Manager::ManagerImpl::getBinaryDataAliasVector(DBDataType dataType, AliasVector &aliasVector)
266 return try_catch([&] {
268 MessageBuffer send, recv;
269 Serialization::Serialize(send, static_cast<int>(LogicCommand::GET_LIST));
270 Serialization::Serialize(send, m_counter);
271 Serialization::Serialize(send, static_cast<int>(dataType));
273 int retCode = sendToServer(
274 SERVICE_SOCKET_CKM_STORAGE,
278 if (CKM_API_SUCCESS != retCode) {
286 Deserialization::Deserialize(recv, command);
287 Deserialization::Deserialize(recv, counter);
288 Deserialization::Deserialize(recv, retCode);
289 Deserialization::Deserialize(recv, tmpDataType);
290 Deserialization::Deserialize(recv, aliasVector);
292 if (counter != m_counter) {
293 return CKM_API_ERROR_UNKNOWN;
300 int Manager::ManagerImpl::getKeyAliasVector(AliasVector &aliasVector) {
301 return getBinaryDataAliasVector(DBDataType::KEY_RSA_PUBLIC, aliasVector);
304 int Manager::ManagerImpl::getCertificateAliasVector(AliasVector &aliasVector) {
305 return getBinaryDataAliasVector(DBDataType::CERTIFICATE, aliasVector);
308 int Manager::ManagerImpl::getDataAliasVector(AliasVector &aliasVector) {
309 return getBinaryDataAliasVector(DBDataType::BINARY_DATA, aliasVector);
312 int Manager::ManagerImpl::createKeyPairRSA(
313 const int size, // size in bits [1024, 2048, 4096]
314 const Alias &privateKeyAlias,
315 const Alias &publicKeyAlias,
316 const Policy &policyPrivateKey,
317 const Policy &policyPublicKey)
320 int my_counter = m_counter;
321 return try_catch([&] {
323 MessageBuffer send, recv;
324 Serialization::Serialize(send, static_cast<int>(LogicCommand::CREATE_KEY_PAIR_RSA));
325 Serialization::Serialize(send, my_counter);
326 Serialization::Serialize(send, static_cast<int>(size));
327 Serialization::Serialize(send, PolicySerializable(policyPrivateKey));
328 Serialization::Serialize(send, PolicySerializable(policyPublicKey));
329 Serialization::Serialize(send, privateKeyAlias);
330 Serialization::Serialize(send, publicKeyAlias);
332 int retCode = sendToServer(
333 SERVICE_SOCKET_CKM_STORAGE,
337 if (CKM_API_SUCCESS != retCode) {
344 Deserialization::Deserialize(recv, command);
345 Deserialization::Deserialize(recv, counter);
346 Deserialization::Deserialize(recv, retCode);
348 if (counter != my_counter) {
349 return CKM_API_ERROR_UNKNOWN;
356 int Manager::ManagerImpl::createKeyPairECDSA(
358 const Alias &privateKeyAlias,
359 const Alias &publicKeyAlias,
360 const Policy &policyPrivateKey,
361 const Policy &policyPublicKey)
364 int my_counter = m_counter;
365 return try_catch([&] {
367 MessageBuffer send, recv;
368 Serialization::Serialize(send, static_cast<int>(LogicCommand::CREATE_KEY_PAIR_ECDSA));
369 Serialization::Serialize(send, my_counter);
370 Serialization::Serialize(send, static_cast<unsigned int>(type));
371 Serialization::Serialize(send, PolicySerializable(policyPrivateKey));
372 Serialization::Serialize(send, PolicySerializable(policyPublicKey));
373 Serialization::Serialize(send, privateKeyAlias);
374 Serialization::Serialize(send, publicKeyAlias);
376 int retCode = sendToServer(
377 SERVICE_SOCKET_CKM_STORAGE,
381 if (CKM_API_SUCCESS != retCode) {
388 Deserialization::Deserialize(recv, command);
389 Deserialization::Deserialize(recv, counter);
390 Deserialization::Deserialize(recv, retCode);
392 if (counter != my_counter) {
393 return CKM_API_ERROR_UNKNOWN;
402 LogicCommand command,
404 const Certificate &certificate,
406 CertificateVector &certificateChainVector)
408 return try_catch([&] {
410 MessageBuffer send, recv;
411 Serialization::Serialize(send, static_cast<int>(command));
412 Serialization::Serialize(send, counter);
413 Serialization::Serialize(send, certificate.getDER());
414 Serialization::Serialize(send, sendData);
416 int retCode = sendToServer(
417 SERVICE_SOCKET_CKM_STORAGE,
421 if (CKM_API_SUCCESS != retCode) {
427 RawBufferVector rawBufferVector;
429 Deserialization::Deserialize(recv, retCommand);
430 Deserialization::Deserialize(recv, retCounter);
431 Deserialization::Deserialize(recv, retCode);
432 Deserialization::Deserialize(recv, rawBufferVector);
434 if ((counter != retCounter) || (static_cast<int>(command) != retCommand)) {
435 return CKM_API_ERROR_UNKNOWN;
438 if (retCode != CKM_API_SUCCESS) {
442 for (auto &e: rawBufferVector)
443 certificateChainVector.push_back(Certificate(e, DataFormat::FORM_DER));
449 int Manager::ManagerImpl::getCertificateChain(
450 const Certificate &certificate,
451 const CertificateVector &untrustedCertificates,
452 CertificateVector &certificateChainVector)
454 RawBufferVector rawBufferVector;
456 for (auto &e: untrustedCertificates) {
457 rawBufferVector.push_back(e.getDER());
461 LogicCommand::GET_CHAIN_CERT,
465 certificateChainVector);
468 int Manager::ManagerImpl::getCertificateChain(
469 const Certificate &certificate,
470 const AliasVector &untrustedCertificates,
471 CertificateVector &certificateChainVector)
474 (void) untrustedCertificates;
475 (void) certificateChainVector;
476 return CKM_API_ERROR_UNKNOWN;