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.cpp
  18  * @author      Bartlomiej Grzelewski (b.grzelewski@samsung.com)
  19  * @version     1.0
  20  * @brief       CKM 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, "key-manager::api-control", SOCKET_ID_CONTROL},
  53         {SERVICE_SOCKET_CKM_STORAGE, "key-manager::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 (Exception::BrokenProtocol) {
  97         LogError("Broken protocol. Closing socket.");
  98     } catch (const std::string &e) {
  99         LogError("String exception(" << e << "). Closing socket");
 100     } catch (...) {
 101         LogError("Unknown exception. Closing socket.");
 102     }
 103
 104     m_serviceManager->Close(conn);
 105     return false;
 106 }
 107
 108 RawBuffer CKMService::processControl(MessageBuffer &buffer) {
 109     int command;
 110     uid_t user;
 111     ControlCommand cc;
 112     Password newPass, oldPass;
 113
 114     Deserialization::Deserialize(buffer, command);
 115     Deserialization::Deserialize(buffer, user);
 116
 117     LogDebug("Process control. Command: " << command);
 118
 119     cc = static_cast<ControlCommand>(command);
 120
 121     switch(cc) {
 122     case ControlCommand::UNLOCK_USER_KEY:
 123         Deserialization::Deserialize(buffer, newPass);
 124         return m_logic->unlockUserKey(user, newPass);
 125     case ControlCommand::LOCK_USER_KEY:
 126         return m_logic->lockUserKey(user);
 127     case ControlCommand::REMOVE_USER_DATA:
 128         return m_logic->removeUserData(user);
 129     case ControlCommand::CHANGE_USER_PASSWORD:
 130         Deserialization::Deserialize(buffer, oldPass);
 131         Deserialization::Deserialize(buffer, newPass);
 132         return m_logic->changeUserPassword(user, oldPass, newPass);
 133     case ControlCommand::RESET_USER_PASSWORD:
 134         Deserialization::Deserialize(buffer, newPass);
 135         return m_logic->resetUserPassword(user, newPass);
 136     default:
 137         Throw(Exception::BrokenProtocol);
 138     }
 139 }
 140
 141 RawBuffer CKMService::processStorage(Credentials &cred, MessageBuffer &buffer){
 142     int command;
 143     int commandId;
 144     int tmpDataType;
 145     Alias alias;
 146     std::string user;
 147
 148     Deserialization::Deserialize(buffer, command);
 149     Deserialization::Deserialize(buffer, commandId);
 150
 151     LogDebug("Process storage. Command: " << command);
 152
 153     switch(static_cast<LogicCommand>(command)) {
 154         case LogicCommand::SAVE:
 155         {
 156             RawBuffer rawData;
 157             PolicySerializable policy;
 158             Deserialization::Deserialize(buffer, tmpDataType);
 159             Deserialization::Deserialize(buffer, alias);
 160             Deserialization::Deserialize(buffer, rawData);
 161             Deserialization::Deserialize(buffer, policy);
 162             return m_logic->saveData(
 163                 cred,
 164                 commandId,
 165                 static_cast<DBDataType>(tmpDataType),
 166                 alias,
 167                 rawData,
 168                 policy);
 169         }
 170         case LogicCommand::REMOVE:
 171         {
 172             Deserialization::Deserialize(buffer, tmpDataType);
 173             Deserialization::Deserialize(buffer, alias);
 174             return m_logic->removeData(
 175                 cred,
 176                 commandId,
 177                 static_cast<DBDataType>(tmpDataType),
 178                 alias);
 179         }
 180         case LogicCommand::GET:
 181         {
 182             Password password;
 183             Deserialization::Deserialize(buffer, tmpDataType);
 184             Deserialization::Deserialize(buffer, alias);
 185             Deserialization::Deserialize(buffer, password);
 186             return m_logic->getData(
 187                 cred,
 188                 commandId,
 189                 static_cast<DBDataType>(tmpDataType),
 190                 alias,
 191                 password);
 192         }
 193         case LogicCommand::GET_LIST:
 194         {
 195             Deserialization::Deserialize(buffer, tmpDataType);
 196             return m_logic->getDataList(
 197                 cred,
 198                 commandId,
 199                 static_cast<DBDataType>(tmpDataType));
 200         }
 201         case LogicCommand::CREATE_KEY_PAIR_RSA:
 202         {
 203             int size;
 204             Alias privateKeyAlias;
 205             Alias publicKeyAlias;
 206             PolicySerializable policyPrivateKey;
 207             PolicySerializable policyPublicKey;
 208             Deserialization::Deserialize(buffer, size);
 209             Deserialization::Deserialize(buffer, policyPrivateKey);
 210             Deserialization::Deserialize(buffer, policyPublicKey);
 211             Deserialization::Deserialize(buffer, privateKeyAlias);
 212             Deserialization::Deserialize(buffer, publicKeyAlias);
 213             return m_logic->createKeyPairRSA(
 214                 cred,
 215                 commandId,
 216                 size,
 217                 privateKeyAlias,
 218                 publicKeyAlias,
 219                 policyPrivateKey,
 220                 policyPublicKey);
 221         }
 222         case LogicCommand::CREATE_KEY_PAIR_ECDSA:
 223         {
 224             unsigned int type;
 225             Alias privateKeyAlias;
 226             Alias publicKeyAlias;
 227             PolicySerializable policyPrivateKey;
 228             PolicySerializable policyPublicKey;
 229             Deserialization::Deserialize(buffer, type);
 230             Deserialization::Deserialize(buffer, policyPrivateKey);
 231             Deserialization::Deserialize(buffer, policyPublicKey);
 232             Deserialization::Deserialize(buffer, privateKeyAlias);
 233             Deserialization::Deserialize(buffer, publicKeyAlias);
 234             return m_logic->createKeyPairECDSA(
 235                 cred,
 236                 commandId,
 237                 type,
 238                 privateKeyAlias,
 239                 publicKeyAlias,
 240                 policyPrivateKey,
 241                 policyPublicKey);
 242         }
 243         case LogicCommand::GET_CHAIN_CERT:
 244         {
 245             RawBuffer certificate;
 246             RawBufferVector rawBufferVector;
 247             Deserialization::Deserialize(buffer, certificate);
 248             Deserialization::Deserialize(buffer, rawBufferVector);
 249             return m_logic->getCertificateChain(
 250                 cred,
 251                 commandId,
 252                 certificate,
 253                 rawBufferVector);
 254         }
 255         case LogicCommand::GET_CHAIN_ALIAS:
 256         {
 257             RawBuffer certificate;
 258             AliasVector aliasVector;
 259             Deserialization::Deserialize(buffer, certificate);
 260             Deserialization::Deserialize(buffer, aliasVector);
 261             return m_logic->getCertificateChain(
 262                 cred,
 263                 commandId,
 264                 certificate,
 265                 aliasVector);
 266         }
 267         case LogicCommand::CREATE_SIGNATURE:
 268         {
 269             Alias privateKeyAlias;
 270             Password password;        // password for private_key
 271             RawBuffer message;
 272             int padding, hash;
 273             Deserialization::Deserialize(buffer, privateKeyAlias);
 274             Deserialization::Deserialize(buffer, password);
 275             Deserialization::Deserialize(buffer, message);
 276             Deserialization::Deserialize(buffer, hash);
 277             Deserialization::Deserialize(buffer, padding);
 278
 279             return m_logic->createSignature(
 280                   cred,
 281                   commandId,
 282                   privateKeyAlias,
 283                   password,           // password for private_key
 284                   message,
 285                   static_cast<HashAlgorithm>(hash),
 286                   static_cast<RSAPaddingAlgorithm>(padding));
 287         }
 288         case LogicCommand::VERIFY_SIGNATURE:
 289         {
 290             Alias publicKeyOrCertAlias;
 291             Password password;           // password for public_key (optional)
 292             RawBuffer message;
 293             RawBuffer signature;
 294             //HashAlgorithm hash;
 295             //RSAPaddingAlgorithm padding;
 296             int padding, hash;
 297             Deserialization::Deserialize(buffer, publicKeyOrCertAlias);
 298             Deserialization::Deserialize(buffer, password);
 299             Deserialization::Deserialize(buffer, message);
 300             Deserialization::Deserialize(buffer, signature);
 301             Deserialization::Deserialize(buffer, hash);
 302             Deserialization::Deserialize(buffer, padding);
 303             return m_logic->verifySignature(
 304                 cred,
 305                 commandId,
 306                 publicKeyOrCertAlias,
 307                 password,           // password for public_key (optional)
 308                 message,
 309                 signature,
 310                 static_cast<const HashAlgorithm>(hash),
 311                 static_cast<const RSAPaddingAlgorithm>(padding));
 312         }
 313         default:
 314             Throw(Exception::BrokenProtocol);
 315     }
 316 }
 317
 318
 319 void CKMService::close(const CloseEvent &event) {
 320     LogDebug("Close event");
 321     m_connectionInfoMap.erase(event.connectionID.counter);
 322 }
 323
 324 } // namespace CKM
 325