src/manager/client-async/client-manager-async.cpp

   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.cpp
  18  * @author     Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
  19  * @version    1.0
  20  */
  21
  22 #include <ckm/ckm-manager-async.h>
  23 #include <client-manager-async-impl.h>
  24
  25 namespace CKM {
  26
  27 namespace {
  28 RawBufferVector toRawBufferVector(const CertificateShPtrVector& certificates)
  29 {
  30     RawBufferVector rawBufferVector;
  31     for (auto &e: certificates) {
  32         rawBufferVector.push_back(e->getDER());
  33     }
  34     return rawBufferVector;
  35 }
  36
  37 LabelNameVector toLabelNameVector(const AliasVector& aliases)
  38 {
  39     LabelNameVector labelNames;
  40     for (auto &e: aliases) {
  41         AliasSupport helper(e);
  42         labelNames.push_back(std::make_pair(helper.getLabel(), helper.getName()));
  43     }
  44     return labelNames;
  45 }
  46
  47 } // namespace anonymous
  48
  49 ManagerAsync::ManagerAsync()
  50 {
  51     m_impl.reset(new Impl());
  52 }
  53
  54 ManagerAsync::~ManagerAsync()
  55 {
  56     m_impl.reset();
  57 }
  58
  59 void ManagerAsync::saveKey(const ObserverPtr& observer,
  60                            const Alias& alias,
  61                            const KeyShPtr& key,
  62                            const Policy& policy)
  63 {
  64     m_impl->saveKey(observer, alias, key, policy);
  65 }
  66
  67 void ManagerAsync::saveCertificate(const ObserverPtr& observer,
  68                                    const Alias& alias,
  69                                    const CertificateShPtr& cert,
  70                                    const Policy& policy)
  71 {
  72     m_impl->saveCertificate(observer, alias, cert, policy);
  73 }
  74
  75 void ManagerAsync::saveData(const ObserverPtr& observer,
  76                             const Alias& alias,
  77                             const RawBuffer& data,
  78                             const Policy& policy)
  79 {
  80     m_impl->saveData(observer, alias, data, policy);
  81 }
  82
  83 void ManagerAsync::savePKCS12(const ObserverPtr& observer,
  84                               const Alias &alias,
  85                               const PKCS12ShPtr &pkcs,
  86                               const Policy &keyPolicy,
  87                               const Policy &certPolicy)
  88 {
  89     m_impl->savePKCS12(observer, alias, pkcs, keyPolicy, certPolicy);
  90 }
  91
  92 void ManagerAsync::removeAlias(const ObserverPtr& observer, const Alias& alias)
  93 {
  94     m_impl->removeAlias(observer, alias);
  95 }
  96
  97 void ManagerAsync::getKey(const ObserverPtr& observer, const Alias& alias, const Password& password)
  98 {
  99     m_impl->getBinaryData(observer, alias, DataType::DB_KEY_FIRST, password);
 100 }
 101
 102 void ManagerAsync::getCertificate(const ObserverPtr& observer,
 103                                   const Alias& alias,
 104                                   const Password& password)
 105 {
 106     m_impl->getBinaryData(observer, alias, DataType::CERTIFICATE, password);
 107 }
 108
 109 void ManagerAsync::getData(const ObserverPtr& observer,
 110                            const Alias& alias,
 111                            const Password& password)
 112 {
 113     m_impl->getBinaryData(observer, alias, DataType::BINARY_DATA, password);
 114 }
 115
 116 void ManagerAsync::getPKCS12(const ObserverPtr& observer,
 117                              const Alias &alias,
 118                              const Password &keyPassword,
 119                              const Password &certPassword)
 120 {
 121     m_impl->getPKCS12(observer, alias, keyPassword, certPassword);
 122 }
 123
 124 void ManagerAsync::getKeyAliasVector(const ObserverPtr& observer)
 125 {
 126     m_impl->getBinaryDataAliasVector(observer, DataType::DB_KEY_FIRST);
 127 }
 128
 129 void ManagerAsync::getCertificateAliasVector(const ObserverPtr& observer)
 130 {
 131     m_impl->getBinaryDataAliasVector(observer, DataType::CERTIFICATE);
 132 }
 133
 134 void ManagerAsync::getDataAliasVector(const ObserverPtr& observer)
 135 {
 136     m_impl->getBinaryDataAliasVector(observer, DataType::BINARY_DATA);
 137 }
 138
 139 void ManagerAsync::createKeyPairRSA(const ObserverPtr& observer,
 140                                     int size,
 141                                     const Alias& privateKeyAlias,
 142                                     const Alias& publicKeyAlias,
 143                                     const Policy& policyPrivateKey,
 144                                     const Policy& policyPublicKey)
 145 {
 146     m_impl->createKeyPair(observer,
 147                           KeyType::KEY_RSA_PUBLIC,
 148                           size,
 149                           privateKeyAlias,
 150                           publicKeyAlias,
 151                           policyPrivateKey,
 152                           policyPublicKey);
 153 }
 154
 155 void ManagerAsync::createKeyPairDSA(const ObserverPtr& observer,
 156                                     int size,
 157                                     const Alias& privateKeyAlias,
 158                                     const Alias& publicKeyAlias,
 159                                     const Policy& policyPrivateKey,
 160                                     const Policy& policyPublicKey)
 161 {
 162     m_impl->createKeyPair(observer,
 163                           KeyType::KEY_DSA_PUBLIC,
 164                           size,
 165                           privateKeyAlias,
 166                           publicKeyAlias,
 167                           policyPrivateKey,
 168                           policyPublicKey);
 169 }
 170
 171 void ManagerAsync::createKeyPairECDSA(const ObserverPtr& observer,
 172                                       const ElipticCurve type,
 173                                       const Alias& privateKeyAlias,
 174                                       const Alias& publicKeyAlias,
 175                                       const Policy& policyPrivateKey,
 176                                       const Policy& policyPublicKey)
 177 {
 178     m_impl->createKeyPair(observer,
 179                           KeyType::KEY_ECDSA_PUBLIC,
 180                           static_cast<int>(type),
 181                           privateKeyAlias,
 182                           publicKeyAlias,
 183                           policyPrivateKey,
 184                           policyPublicKey);
 185 }
 186
 187 void ManagerAsync::createKeyAES(const ObserverPtr& observer,
 188                                 int size,
 189                                 const Alias &keyAlias,
 190                                 const Policy &policyKey)
 191 {
 192     m_impl->createKeyAES(observer,
 193                          size,
 194                          keyAlias,
 195                          policyKey);
 196 }
 197
 198 void ManagerAsync::getCertificateChain(const ObserverPtr& observer,
 199                                        const CertificateShPtr& certificate,
 200                                        const CertificateShPtrVector& untrustedCertificates,
 201                                        const CertificateShPtrVector& trustedCertificates,
 202                                        bool useSystemTrustedCertificates)
 203 {
 204     m_impl->getCertChain(observer,
 205                          LogicCommand::GET_CHAIN_CERT,
 206                          certificate,
 207                          toRawBufferVector(untrustedCertificates),
 208                          toRawBufferVector(trustedCertificates),
 209                          useSystemTrustedCertificates);
 210 }
 211
 212 void ManagerAsync::getCertificateChain(const ObserverPtr& observer,
 213                                        const CertificateShPtr& certificate,
 214                                        const AliasVector& untrustedCertificates,
 215                                        const AliasVector& trustedCertificates,
 216                                        bool useSystemTrustedCertificates)
 217 {
 218     m_impl->getCertChain(observer,
 219                          LogicCommand::GET_CHAIN_ALIAS,
 220                          certificate,
 221                          toLabelNameVector(untrustedCertificates),
 222                          toLabelNameVector(trustedCertificates),
 223                          useSystemTrustedCertificates);
 224 }
 225
 226 void ManagerAsync::createSignature(const ObserverPtr& observer,
 227                                    const Alias& privateKeyAlias,
 228                                    const Password& password,
 229                                    const RawBuffer& message,
 230                                    const HashAlgorithm hash,
 231                                    const RSAPaddingAlgorithm padding)
 232 {
 233     m_impl->createSignature(observer, privateKeyAlias, password, message, hash, padding);
 234 }
 235
 236 void ManagerAsync::verifySignature(const ObserverPtr& observer,
 237                                    const Alias& publicKeyOrCertAlias,
 238                                    const Password& password,
 239                                    const RawBuffer& message,
 240                                    const RawBuffer& signature,
 241                                    const HashAlgorithm hash,
 242                                    const RSAPaddingAlgorithm padding)
 243 {
 244     m_impl->verifySignature(observer, publicKeyOrCertAlias, password, message, signature, hash, padding);
 245 }
 246
 247 void ManagerAsync::ocspCheck(const ObserverPtr& observer,
 248                              const CertificateShPtrVector& certificateChainVector)
 249 {
 250     m_impl->ocspCheck(observer, certificateChainVector);
 251 }
 252
 253 void ManagerAsync::setPermission(const ObserverPtr& observer,
 254                                  const Alias& alias,
 255                                  const Label& accessor,
 256                                  PermissionMask permissionMask)
 257 {
 258     m_impl->setPermission(observer, alias, accessor, permissionMask);
 259 }
 260
 261 void ManagerAsync::encrypt(
 262         const ObserverPtr& observer,
 263         const CryptoAlgorithm& algo,
 264         const Alias& keyAlias,
 265         const Password& password,
 266         const RawBuffer& plain)
 267 {
 268     m_impl->crypt(observer, algo, keyAlias, password, plain, true);
 269 }
 270
 271 void ManagerAsync::decrypt(
 272         const ObserverPtr& observer,
 273         const CryptoAlgorithm& algo,
 274         const Alias& keyAlias,
 275         const Password& password,
 276         const RawBuffer& encrypted)
 277 {
 278     m_impl->crypt(observer, algo, keyAlias, password, encrypted, false);
 279 }
 280
 281 } // namespace CKM
 282