src/manager/service/ckm-service.cpp

   1 /*
   2  *  Copyright (c) 2000 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Licensed under the Apache License, Version 2.0 (the "License");
   5  *  you may not use this file except in compliance with the License.
   6  *  You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License
  15  *
  16  *
  17  * @file        ckm-service.h
  18  * @author      Bartlomiej Grzelewski (b.grzelewski@samsung.com)
  19  * @version     1.0
  20  * @brief       Sample service implementation.
  21  */
  22 #include <service-thread.h>
  23 #include <generic-socket-manager.h>
  24 #include <connection-info.h>
  25 #include <message-buffer.h>
  26 #include <protocols.h>
  27
  28 #include <dpl/serialization.h>
  29 #include <dpl/log/log.h>
  30
  31 #include <ckm-service.h>
  32 #include <ckm-logic.h>
  33
  34 namespace {
  35 const CKM::InterfaceID SOCKET_ID_CONTROL = 0;
  36 const CKM::InterfaceID SOCKET_ID_STORAGE = 1;
  37 } // namespace anonymous
  38
  39 namespace CKM {
  40
  41 CKMService::CKMService()
  42   : m_logic(new CKMLogic)
  43 {}
  44
  45 CKMService::~CKMService() {
  46     delete m_logic;
  47 }
  48
  49 GenericSocketService::ServiceDescriptionVector CKMService::GetServiceDescription()
  50 {
  51     return ServiceDescriptionVector {
  52         {SERVICE_SOCKET_CKM_CONTROL, "ckm::api-control", SOCKET_ID_CONTROL},
  53         {SERVICE_SOCKET_CKM_STORAGE, "ckm::api-storage", SOCKET_ID_STORAGE}
  54     };
  55 }
  56
  57 void CKMService::accept(const AcceptEvent &event) {
  58     LogDebug("Accept event");
  59     auto &info = m_connectionInfoMap[event.connectionID.counter];
  60     info.interfaceID = event.interfaceID;
  61     info.credentials = event.credentials;
  62 }
  63
  64 void CKMService::write(const WriteEvent &event) {
  65     LogDebug("Write event (" << event.size << " bytes)");
  66 }
  67
  68 void CKMService::process(const ReadEvent &event) {
  69     LogDebug("Read event");
  70     auto &info = m_connectionInfoMap[event.connectionID.counter];
  71     info.buffer.Push(event.rawBuffer);
  72     while(processOne(event.connectionID, info));
  73 }
  74
  75 bool CKMService::processOne(
  76     const ConnectionID &conn,
  77     ConnectionInfo &info)
  78 {
  79     LogDebug ("process One");
  80     RawBuffer response;
  81
  82     Try {
  83         if (!info.buffer.Ready())
  84             return false;
  85
  86         if (info.interfaceID == SOCKET_ID_CONTROL)
  87             response = processControl(info.buffer);
  88         else
  89             response = processStorage(info.credentials, info.buffer);
  90
  91         m_serviceManager->Write(conn, response);
  92
  93         return true;
  94     } Catch (MessageBuffer::Exception::Base) {
  95         LogError("Broken protocol. Closing socket.");
  96     } catch (const std::string &e) {
  97         LogError("String exception(" << e << "). Closing socket");
  98     } catch (...) {
  99         LogError("Unknown exception. Closing socket.");
 100     }
 101
 102     m_serviceManager->Close(conn);
 103     return false;
 104 }
 105
 106 RawBuffer CKMService::processControl(MessageBuffer &buffer) {
 107     int command;
 108     uid_t user;
 109     ControlCommand cc;
 110     std::string newPass, oldPass;
 111
 112     Deserialization::Deserialize(buffer, command);
 113     Deserialization::Deserialize(buffer, user);
 114
 115     cc = static_cast<ControlCommand>(command);
 116
 117     switch(cc) {
 118     case ControlCommand::UNLOCK_USER_KEY:
 119         Deserialization::Deserialize(buffer, newPass);
 120         return m_logic->unlockUserKey(user, newPass);
 121     case ControlCommand::LOCK_USER_KEY:
 122         return m_logic->lockUserKey(user);
 123     case ControlCommand::REMOVE_USER_DATA:
 124         return m_logic->removeUserData(user);
 125     case ControlCommand::CHANGE_USER_PASSWORD:
 126         Deserialization::Deserialize(buffer, oldPass);
 127         Deserialization::Deserialize(buffer, newPass);
 128         return m_logic->changeUserPassword(user, oldPass, newPass);
 129     case ControlCommand::RESET_USER_PASSWORD:
 130         Deserialization::Deserialize(buffer, newPass);
 131         return m_logic->resetUserPassword(user, newPass);
 132     default:
 133         // TODO
 134         throw 1; // broken protocol
 135     }
 136 }
 137
 138 RawBuffer CKMService::processStorage(Credentials &cred, MessageBuffer &buffer){
 139     int command;
 140     int commandId;
 141     int tmpDataType;
 142     Alias alias;
 143     std::string user;
 144
 145     Deserialization::Deserialize(buffer, command);
 146     Deserialization::Deserialize(buffer, commandId);
 147
 148     switch(static_cast<LogicCommand>(command)) {
 149         case LogicCommand::SAVE:
 150         {
 151             RawBuffer rawData;
 152             PolicySerializable policy;
 153             Deserialization::Deserialize(buffer, tmpDataType);
 154             Deserialization::Deserialize(buffer, alias);
 155             Deserialization::Deserialize(buffer, rawData);
 156             Deserialization::Deserialize(buffer, policy);
 157             return m_logic->saveData(
 158                 cred,
 159                 commandId,
 160                 static_cast<DBDataType>(tmpDataType),
 161                 alias,
 162                 rawData,
 163                 policy);
 164         }
 165         case LogicCommand::REMOVE:
 166         {
 167             Deserialization::Deserialize(buffer, tmpDataType);
 168             Deserialization::Deserialize(buffer, alias);
 169             return m_logic->removeData(
 170                 cred,
 171                 commandId,
 172                 static_cast<DBDataType>(tmpDataType),
 173                 alias);
 174         }
 175         case LogicCommand::GET:
 176         {
 177             std::string password;
 178             Deserialization::Deserialize(buffer, tmpDataType);
 179             Deserialization::Deserialize(buffer, alias);
 180             Deserialization::Deserialize(buffer, password);
 181             return m_logic->getData(
 182                 cred,
 183                 commandId,
 184                 static_cast<DBDataType>(tmpDataType),
 185                 alias,
 186                 password);
 187         }
 188         case LogicCommand::GET_LIST:
 189         {
 190             Deserialization::Deserialize(buffer, tmpDataType);
 191             return m_logic->getDataList(
 192                 cred,
 193                 commandId,
 194                 static_cast<DBDataType>(tmpDataType));
 195         }
 196         case LogicCommand::CREATE_KEY_PAIR_RSA:
 197         {
 198             int size;
 199             Alias privateKeyAlias;
 200             Alias publicKeyAlias;
 201             PolicySerializable policyPrivateKey;
 202             PolicySerializable policyPublicKey;
 203             Deserialization::Deserialize(buffer, size);
 204             Deserialization::Deserialize(buffer, policyPrivateKey);
 205             Deserialization::Deserialize(buffer, policyPublicKey);
 206             Deserialization::Deserialize(buffer, privateKeyAlias);
 207             Deserialization::Deserialize(buffer, publicKeyAlias);
 208             return m_logic->createKeyPairRSA(
 209                 cred,
 210                 commandId,
 211                 size,
 212                 privateKeyAlias,
 213                 publicKeyAlias,
 214                 policyPrivateKey,
 215                 policyPublicKey);
 216         }
 217         case LogicCommand::CREATE_KEY_PAIR_ECDSA:
 218         {
 219             unsigned int type;
 220             Alias privateKeyAlias;
 221             Alias publicKeyAlias;
 222             PolicySerializable policyPrivateKey;
 223             PolicySerializable policyPublicKey;
 224             Deserialization::Deserialize(buffer, type);
 225             Deserialization::Deserialize(buffer, policyPrivateKey);
 226             Deserialization::Deserialize(buffer, policyPublicKey);
 227             Deserialization::Deserialize(buffer, privateKeyAlias);
 228             Deserialization::Deserialize(buffer, publicKeyAlias);
 229             return m_logic->createKeyPairECDSA(
 230                 cred,
 231                 commandId,
 232                 type,
 233                 privateKeyAlias,
 234                 publicKeyAlias,
 235                 policyPrivateKey,
 236                 policyPublicKey);
 237         }
 238         case LogicCommand::GET_CHAIN_CERT:
 239         {
 240             RawBuffer certificate;
 241             RawBufferVector rawBufferVector;
 242             Deserialization::Deserialize(buffer, certificate);
 243             Deserialization::Deserialize(buffer, rawBufferVector);
 244             return m_logic->getCertificateChain(
 245                 cred,
 246                 commandId,
 247                 certificate,
 248                 rawBufferVector);
 249         }
 250         case LogicCommand::GET_CHAIN_ALIAS:
 251         {
 252             RawBuffer certificate;
 253             AliasVector aliasVector;
 254             Deserialization::Deserialize(buffer, certificate);
 255             Deserialization::Deserialize(buffer, aliasVector);
 256             return m_logic->getCertificateChain(
 257                 cred,
 258                 commandId,
 259                 certificate,
 260                 aliasVector);
 261         }
 262         default:
 263         // TODO
 264             throw 1; // broken protocol
 265     }
 266 }
 267
 268
 269 void CKMService::close(const CloseEvent &event) {
 270     LogDebug("Close event");
 271     m_connectionInfoMap.erase(event.connectionID.counter);
 272 }
 273
 274 } // namespace CKM
 275