src/manager/client-async/client-manager-async-impl.h

   1 /*
   2  *  Copyright (c) 2000 - 2015 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       client-manager-async-impl.h
  18  * @author     Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
  19  * @version    1.0
  20  */
  21
  22 #pragma once
  23
  24 #include <ckm/ckm-manager-async.h>
  25 #include <memory>
  26 #include <connection-thread.h>
  27 #include <protocols.h>
  28 #include <noncopyable.h>
  29
  30 namespace CKM {
  31
  32 class ManagerAsync::Impl
  33 {
  34 public:
  35     Impl();
  36
  37     NONCOPYABLE(Impl);
  38
  39     virtual ~Impl();
  40
  41     void saveKey(
  42             const ObserverPtr& observer,
  43             const Alias& alias,
  44             const KeyShPtr& key,
  45             const Policy& policy);
  46     void saveCertificate(
  47             const ObserverPtr& observer,
  48             const Alias& alias,
  49             const CertificateShPtr& cert,
  50             const Policy& policy);
  51     void saveData(
  52             const ObserverPtr& observer,
  53             const Alias& alias,
  54             const RawBuffer& data,
  55             const Policy& policy);
  56     void savePKCS12(
  57             const ObserverPtr& observer,
  58             const Alias &alias,
  59             const PKCS12ShPtr &pkcs,
  60             const Policy &keyPolicy,
  61             const Policy &certPolicy);
  62
  63     void createSignature(
  64             const ObserverPtr& observer,
  65             const Alias& privateKeyAlias,
  66             const Password& password,
  67             const RawBuffer& message,
  68             const CryptoAlgorithm& cAlgorithm);
  69     void verifySignature(
  70             const ObserverPtr& observer,
  71             const Alias& publicKeyOrCertAlias,
  72             const Password& password,
  73             const RawBuffer& message,
  74             const RawBuffer& signature,
  75             const CryptoAlgorithm& cAlgorithm);
  76
  77     void ocspCheck(
  78             const ObserverPtr& observer,
  79             const CertificateShPtrVector& certificateChainVector);
  80
  81     void setPermission(
  82             const ObserverPtr& observer,
  83             const Alias& alias,
  84             const Label& accessor,
  85             PermissionMask permissionMask);
  86
  87     // generic methods
  88     void saveBinaryData(
  89             const ManagerAsync::ObserverPtr& observer,
  90             const Alias& alias,
  91             DataType dataType,
  92             const RawBuffer& rawData,
  93             const Policy& policy);
  94
  95     void removeAlias(
  96             const ManagerAsync::ObserverPtr& observer,
  97             const Alias &alias);
  98
  99     void getBinaryData(
 100             const ManagerAsync::ObserverPtr& observer,
 101             const Alias &alias,
 102             DataType sendDataType,
 103             const Password &password);
 104
 105     void getPKCS12(
 106             const ManagerAsync::ObserverPtr& observer,
 107             const Alias &alias,
 108             const Password &keyPassword,
 109             const Password &certPassword);
 110
 111     void getBinaryDataAliasVector(
 112             const ManagerAsync::ObserverPtr& observer,
 113             DataType dataType);
 114
 115     void createKeyPair(
 116             const ManagerAsync::ObserverPtr& observer,
 117             const KeyType key_type,
 118             const int     additional_param,
 119             const Alias  &privateKeyAlias,
 120             const Alias  &publicKeyAlias,
 121             const Policy &policyPrivateKey,
 122             const Policy &policyPublicKey);
 123
 124     void createKeyAES(
 125             const ManagerAsync::ObserverPtr& observer,
 126             const size_t  size,
 127             const Alias  &keyAlias,
 128             const Policy &policyKey);
 129
 130     template <typename T>
 131     void getCertChain(
 132             const ManagerAsync::ObserverPtr& observer,
 133             LogicCommand command,
 134             const CertificateShPtr &certificate,
 135             const T &untrusted,
 136             const T &trusted,
 137             bool useSystemTrustedCertificates)
 138     {
 139         observerCheck(observer);
 140         if (!certificate) {
 141             observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
 142             return;
 143         }
 144         try_catch_async([&] {
 145             sendToStorage(observer,
 146                           static_cast<int>(command),
 147                           m_counter,
 148                           certificate->getDER(),
 149                           untrusted,
 150                           trusted,
 151                           useSystemTrustedCertificates);
 152         }, [&observer](int error){ observer->ReceivedError(error); } );
 153     }
 154
 155     void crypt(
 156             const ObserverPtr& observer,
 157             const CryptoAlgorithm& algo,
 158             const Alias& keyAlias,
 159             const Password& password,
 160             const RawBuffer& input,
 161             bool encryption);
 162
 163 private:
 164
 165     template <typename... Args>
 166     void sendToStorage(const ManagerAsync::ObserverPtr& observer, const Args&... args)
 167     {
 168         m_counter++; // yes, it changes m_counter argument passed in args
 169
 170         auto send = MessageBuffer::Serialize(args...);
 171         thread()->sendMessage(AsyncRequest(observer,
 172                                            SERVICE_SOCKET_CKM_STORAGE,
 173                                            send.Pop(),
 174                                            m_counter));
 175     }
 176
 177     void observerCheck(const ManagerAsync::ObserverPtr& observer);
 178
 179     typedef std::unique_ptr<ConnectionThread> ConnectionThreadPtr;
 180
 181     ConnectionThreadPtr& thread() {
 182         if (!m_thread || m_thread->finished()) {
 183             m_thread.reset(new ConnectionThread());
 184             m_thread->run();
 185         }
 186         return m_thread;
 187     }
 188
 189     ConnectionThreadPtr m_thread;
 190
 191     static int m_counter;
 192 };
 193
 194 } // namespace CKM