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

   1 /* Copyright (c) 2000 - 2013 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 <dpl/serialization.h>
  22 #include <dpl/log/log.h>
  23
  24 #include <client-manager-impl.h>
  25 #include <client-common.h>
  26 #include <message-buffer.h>
  27 #include <protocols.h>
  28
  29 namespace CKM {
  30
  31 int Manager::ManagerImpl::saveBinaryData(
  32     const Alias &alias,
  33     DBDataType dataType,
  34     const RawBuffer &rawData,
  35     const Policy &policy)
  36 {
  37     m_counter++;
  38
  39     return try_catch([&] {
  40         if (alias.empty() || rawData.empty())
  41             return KEY_MANAGER_API_ERROR_INPUT_PARAM;
  42
  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));
  50
  51         int retCode = sendToServer(
  52             SERVICE_SOCKET_CKM_STORAGE,
  53             send.Pop(),
  54             recv);
  55
  56         if (KEY_MANAGER_API_SUCCESS != retCode) {
  57             return retCode;
  58         }
  59
  60         int command;
  61         int counter;
  62         int opType;
  63         Deserialization::Deserialize(recv, command);
  64         Deserialization::Deserialize(recv, counter);
  65         Deserialization::Deserialize(recv, retCode);
  66         Deserialization::Deserialize(recv, opType);
  67
  68         if (counter != m_counter) {
  69             return KEY_MANAGER_API_ERROR_UNKNOWN;
  70         }
  71
  72         return retCode;
  73     });
  74 }
  75
  76 int Manager::ManagerImpl::saveKey(const Alias &alias, const Key &key, const Policy &policy) {
  77     return saveBinaryData(alias, toDBDataType(key.getType()), key.getDER(), policy);
  78 }
  79
  80 int Manager::ManagerImpl::saveCertificate(
  81     const Alias &alias,
  82     const Certificate &cert,
  83     const Policy &policy)
  84 {
  85     return saveBinaryData(alias, DBDataType::CERTIFICATE, cert.getDER(), policy);
  86 }
  87
  88 int Manager::ManagerImpl::saveData(const Alias &alias, const RawBuffer &rawData, const Policy &policy) {
  89     return saveBinaryData(alias, DBDataType::BINARY_DATA, rawData, policy);
  90 }
  91
  92 int Manager::ManagerImpl::removeBinaryData(const Alias &alias, DBDataType dataType)
  93 {
  94     return try_catch([&] {
  95         if (alias.empty())
  96             return KEY_MANAGER_API_ERROR_INPUT_PARAM;
  97
  98         MessageBuffer send, recv;
  99         Serialization::Serialize(send, static_cast<int>(LogicCommand::REMOVE));
 100         Serialization::Serialize(send, m_counter);
 101         Serialization::Serialize(send, static_cast<int>(dataType));
 102         Serialization::Serialize(send, alias);
 103
 104         int retCode = sendToServer(
 105             SERVICE_SOCKET_CKM_STORAGE,
 106             send.Pop(),
 107             recv);
 108
 109         if (KEY_MANAGER_API_SUCCESS != retCode) {
 110             return retCode;
 111         }
 112
 113         int command;
 114         int counter;
 115         int opType;
 116         Deserialization::Deserialize(recv, command);
 117         Deserialization::Deserialize(recv, counter);
 118         Deserialization::Deserialize(recv, retCode);
 119         Deserialization::Deserialize(recv, opType);
 120
 121         if (counter != m_counter) {
 122             return KEY_MANAGER_API_ERROR_UNKNOWN;
 123         }
 124
 125         return retCode;
 126     });
 127 }
 128
 129 int Manager::ManagerImpl::removeKey(const Alias &alias) {
 130     return removeBinaryData(alias, DBDataType::KEY_RSA_PUBLIC);
 131 }
 132
 133 int Manager::ManagerImpl::removeCertificate(const Alias &alias) {
 134     return removeBinaryData(alias, DBDataType::CERTIFICATE);
 135 }
 136
 137 int Manager::ManagerImpl::removeData(const Alias &alias) {
 138     return removeBinaryData(alias, DBDataType::BINARY_DATA);
 139 }
 140
 141 int Manager::ManagerImpl::getBinaryData(
 142     const Alias &alias,
 143     DBDataType sendDataType,
 144     const std::string &password,
 145     DBDataType &recvDataType,
 146     RawBuffer &rawData)
 147 {
 148     return try_catch([&] {
 149         if (alias.empty())
 150             return KEY_MANAGER_API_ERROR_INPUT_PARAM;
 151
 152         MessageBuffer send, recv;
 153         Serialization::Serialize(send, static_cast<int>(LogicCommand::GET));
 154         Serialization::Serialize(send, m_counter);
 155         Serialization::Serialize(send, static_cast<int>(sendDataType));
 156         Serialization::Serialize(send, alias);
 157         Serialization::Serialize(send, password);
 158
 159         int retCode = sendToServer(
 160             SERVICE_SOCKET_CKM_STORAGE,
 161             send.Pop(),
 162             recv);
 163
 164         if (KEY_MANAGER_API_SUCCESS != retCode) {
 165             return retCode;
 166         }
 167
 168         int command;
 169         int counter;
 170         int tmpDataType;
 171         Deserialization::Deserialize(recv, command);
 172         Deserialization::Deserialize(recv, counter);
 173         Deserialization::Deserialize(recv, retCode);
 174         Deserialization::Deserialize(recv, tmpDataType);
 175         Deserialization::Deserialize(recv, rawData);
 176         recvDataType = static_cast<DBDataType>(tmpDataType);
 177
 178         if (counter != m_counter) {
 179             return KEY_MANAGER_API_ERROR_UNKNOWN;
 180         }
 181
 182         return retCode;
 183     });
 184 }
 185
 186 int Manager::ManagerImpl::getKey(const Alias &alias, const std::string &password, Key &key) {
 187     DBDataType recvDataType;
 188     RawBuffer rawData;
 189
 190     int retCode = getBinaryData(
 191         alias,
 192         DBDataType::KEY_RSA_PUBLIC,
 193         password,
 194         recvDataType,
 195         rawData);
 196
 197     if (retCode != KEY_MANAGER_API_SUCCESS)
 198         return retCode;
 199
 200     Key keyParsed(rawData);
 201
 202     if (keyParsed.empty()) {
 203         LogDebug("Key empty - failed to parse!");
 204         return KEY_MANAGER_API_ERROR_BAD_RESPONSE;
 205     }
 206
 207     key = keyParsed;
 208
 209     return KEY_MANAGER_API_SUCCESS;
 210 }
 211
 212 int Manager::ManagerImpl::getCertificate(const Alias &alias, const std::string &password, Certificate &cert)
 213 {
 214     DBDataType recvDataType;
 215     RawBuffer rawData;
 216
 217     int retCode = getBinaryData(
 218         alias,
 219         DBDataType::CERTIFICATE,
 220         password,
 221         recvDataType,
 222         rawData);
 223
 224     if (retCode != KEY_MANAGER_API_SUCCESS)
 225         return retCode;
 226
 227     if (recvDataType != DBDataType::CERTIFICATE)
 228         return KEY_MANAGER_API_ERROR_BAD_RESPONSE;
 229
 230     Certificate certParsed(rawData, DataFormat::FORM_DER);
 231
 232     if (certParsed.empty())
 233         return KEY_MANAGER_API_ERROR_BAD_RESPONSE;
 234
 235     cert = certParsed;
 236
 237     return KEY_MANAGER_API_SUCCESS;
 238 }
 239
 240 int Manager::ManagerImpl::getData(const Alias &alias, const std::string &password, RawBuffer &rawData)
 241 {
 242     DBDataType recvDataType;
 243
 244     int retCode = getBinaryData(
 245         alias,
 246         DBDataType::BINARY_DATA,
 247         password,
 248         recvDataType,
 249         rawData);
 250
 251     if (retCode != KEY_MANAGER_API_SUCCESS)
 252         return retCode;
 253
 254     if (recvDataType != DBDataType::BINARY_DATA)
 255         return KEY_MANAGER_API_ERROR_BAD_RESPONSE;
 256
 257     return KEY_MANAGER_API_SUCCESS;
 258 }
 259
 260 int Manager::ManagerImpl::getBinaryDataAliasVector(DBDataType dataType, AliasVector &aliasVector)
 261 {
 262     return try_catch([&] {
 263
 264         MessageBuffer send, recv;
 265         Serialization::Serialize(send, static_cast<int>(LogicCommand::GET_LIST));
 266         Serialization::Serialize(send, m_counter);
 267         Serialization::Serialize(send, static_cast<int>(dataType));
 268
 269         int retCode = sendToServer(
 270             SERVICE_SOCKET_CKM_STORAGE,
 271             send.Pop(),
 272             recv);
 273
 274         if (KEY_MANAGER_API_SUCCESS != retCode) {
 275             return retCode;
 276         }
 277
 278         int command;
 279         int counter;
 280         int tmpDataType;
 281
 282         Deserialization::Deserialize(recv, command);
 283         Deserialization::Deserialize(recv, counter);
 284         Deserialization::Deserialize(recv, retCode);
 285         Deserialization::Deserialize(recv, tmpDataType);
 286         Deserialization::Deserialize(recv, aliasVector);
 287
 288         if (counter != m_counter) {
 289             return KEY_MANAGER_API_ERROR_UNKNOWN;
 290         }
 291
 292         return retCode;
 293     });
 294 }
 295
 296 int Manager::ManagerImpl::getKeyAliasVector(AliasVector &aliasVector) {
 297     return getBinaryDataAliasVector(DBDataType::KEY_RSA_PUBLIC, aliasVector);
 298 }
 299
 300 int Manager::ManagerImpl::getCertificateAliasVector(AliasVector &aliasVector) {
 301     return getBinaryDataAliasVector(DBDataType::CERTIFICATE, aliasVector);
 302 }
 303
 304 int Manager::ManagerImpl::getDataAliasVector(AliasVector &aliasVector) {
 305     return getBinaryDataAliasVector(DBDataType::BINARY_DATA, aliasVector);
 306 }
 307
 308 int Manager::ManagerImpl::createKeyPairRSA(
 309     const int size,              // size in bits [1024, 2048, 4096]
 310     const Alias &privateKeyAlias,
 311     const Alias &publicKeyAlias,
 312     const Policy &policyPrivateKey,
 313     const Policy &policyPublicKey)
 314 {
 315     m_counter++;
 316     int my_counter = m_counter;
 317     return try_catch([&] {
 318
 319         MessageBuffer send, recv;
 320         Serialization::Serialize(send, static_cast<int>(LogicCommand::CREATE_KEY_PAIR_RSA));
 321         Serialization::Serialize(send, my_counter);
 322         Serialization::Serialize(send, static_cast<int>(size));
 323         Serialization::Serialize(send, PolicySerializable(policyPrivateKey));
 324         Serialization::Serialize(send, PolicySerializable(policyPublicKey));
 325         Serialization::Serialize(send, privateKeyAlias);
 326         Serialization::Serialize(send, publicKeyAlias);
 327
 328
 329
 330         int retCode = sendToServer(
 331             SERVICE_SOCKET_CKM_STORAGE,
 332             send.Pop(),
 333             recv);
 334
 335         if (KEY_MANAGER_API_SUCCESS != retCode) {
 336             return retCode;
 337         }
 338
 339         int command;
 340         int counter;
 341
 342
 343         Deserialization::Deserialize(recv, command);
 344         Deserialization::Deserialize(recv, counter);
 345         Deserialization::Deserialize(recv, retCode);
 346
 347         if (counter != my_counter) {
 348             return KEY_MANAGER_API_ERROR_UNKNOWN;
 349         }
 350
 351         return retCode;
 352     });
 353 }
 354
 355 int Manager::ManagerImpl::createKeyPairECDSA(
 356     ElipticCurve type,
 357     const Alias &privateKeyAlias,
 358     const Alias &publicKeyAlias,
 359     const Policy &policyPrivateKey,
 360     const Policy &policyPublicKey)
 361 {
 362     m_counter++;
 363     int my_counter = m_counter;
 364     return try_catch([&] {
 365
 366         MessageBuffer send, recv;
 367         Serialization::Serialize(send, static_cast<int>(LogicCommand::CREATE_KEY_PAIR_ECDSA));
 368         Serialization::Serialize(send, my_counter);
 369         Serialization::Serialize(send, static_cast<unsigned int>(type));
 370         Serialization::Serialize(send, PolicySerializable(policyPrivateKey));
 371         Serialization::Serialize(send, PolicySerializable(policyPublicKey));
 372         Serialization::Serialize(send, privateKeyAlias);
 373         Serialization::Serialize(send, publicKeyAlias);
 374
 375
 376         int retCode = sendToServer(
 377             SERVICE_SOCKET_CKM_STORAGE,
 378             send.Pop(),
 379             recv);
 380
 381         if (KEY_MANAGER_API_SUCCESS != retCode) {
 382             return retCode;
 383         }
 384
 385         int command;
 386         int counter;
 387
 388         Deserialization::Deserialize(recv, command);
 389         Deserialization::Deserialize(recv, counter);
 390         Deserialization::Deserialize(recv, retCode);
 391
 392         if (counter != my_counter) {
 393             return KEY_MANAGER_API_ERROR_UNKNOWN;
 394         }
 395
 396         return retCode;
 397     });
 398 }
 399 } // namespace CKM
 400