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