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 HashAlgorithm hash,
  69             const RSAPaddingAlgorithm padding);
  70     void verifySignature(
  71             const ObserverPtr& observer,
  72             const Alias& publicKeyOrCertAlias,
  73             const Password& password,
  74             const RawBuffer& message,
  75             const RawBuffer& signature,
  76             const HashAlgorithm hash,
  77             const RSAPaddingAlgorithm padding);
  78
  79     void ocspCheck(
  80             const ObserverPtr& observer,
  81             const CertificateShPtrVector& certificateChainVector);
  82
  83     void setPermission(
  84             const ObserverPtr& observer,
  85             const Alias& alias,
  86             const Label& accessor,
  87             PermissionMask permissionMask);
  88
  89     // generic methods
  90     void saveBinaryData(
  91             const ManagerAsync::ObserverPtr& observer,
  92             const Alias& alias,
  93             DataType dataType,
  94             const RawBuffer& rawData,
  95             const Policy& policy);
  96
  97     void removeAlias(
  98             const ManagerAsync::ObserverPtr& observer,
  99             const Alias &alias);
 100
 101     void getBinaryData(
 102             const ManagerAsync::ObserverPtr& observer,
 103             const Alias &alias,
 104             DataType sendDataType,
 105             const Password &password);
 106
 107     void getPKCS12(
 108             const ManagerAsync::ObserverPtr& observer,
 109             const Alias &alias,
 110             const Password &keyPassword,
 111             const Password &certPassword);
 112
 113     void getBinaryDataAliasVector(
 114             const ManagerAsync::ObserverPtr& observer,
 115             DataType dataType);
 116
 117     void createKeyPair(
 118             const ManagerAsync::ObserverPtr& observer,
 119             const KeyType key_type,
 120             const int     additional_param,
 121             const Alias  &privateKeyAlias,
 122             const Alias  &publicKeyAlias,
 123             const Policy &policyPrivateKey,
 124             const Policy &policyPublicKey);
 125
 126     void createKeyAES(
 127             const ManagerAsync::ObserverPtr& observer,
 128             const size_t  size,
 129             const Alias  &keyAlias,
 130             const Policy &policyKey);
 131
 132     template <typename T>
 133     void getCertChain(
 134             const ManagerAsync::ObserverPtr& observer,
 135             LogicCommand command,
 136             const CertificateShPtr &certificate,
 137             const T &untrusted,
 138             const T &trusted,
 139             bool useSystemTrustedCertificates)
 140     {
 141         observerCheck(observer);
 142         if (!certificate) {
 143             observer->ReceivedError(CKM_API_ERROR_INPUT_PARAM);
 144             return;
 145         }
 146         try_catch_async([&] {
 147             sendToStorage(observer,
 148                           static_cast<int>(command),
 149                           m_counter,
 150                           certificate->getDER(),
 151                           untrusted,
 152                           trusted,
 153                           useSystemTrustedCertificates);
 154         }, [&observer](int error){ observer->ReceivedError(error); } );
 155     }
 156
 157     void crypt(
 158             const ObserverPtr& observer,
 159             const CryptoAlgorithm& algo,
 160             const Alias& keyAlias,
 161             const Password& password,
 162             const RawBuffer& input,
 163             bool encryption);
 164
 165 private:
 166
 167     template <typename... Args>
 168     void sendToStorage(const ManagerAsync::ObserverPtr& observer, const Args&... args)
 169     {
 170         m_counter++; // yes, it changes m_counter argument passed in args
 171
 172         auto send = MessageBuffer::Serialize(args...);
 173         thread()->sendMessage(AsyncRequest(observer,
 174                                            SERVICE_SOCKET_CKM_STORAGE,
 175                                            send.Pop(),
 176                                            m_counter));
 177     }
 178
 179     void observerCheck(const ManagerAsync::ObserverPtr& observer);
 180
 181     typedef std::unique_ptr<ConnectionThread> ConnectionThreadPtr;
 182
 183     ConnectionThreadPtr& thread() {
 184         if (!m_thread || m_thread->finished()) {
 185             m_thread.reset(new ConnectionThread());
 186             m_thread->run();
 187         }
 188         return m_thread;
 189     }
 190
 191     ConnectionThreadPtr m_thread;
 192
 193     static int m_counter;
 194 };
 195
 196 } // namespace CKM