src/manager/client-async/client-manager-async.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       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 }
 193
 194 void ManagerAsync::getCertificateChain(const ObserverPtr& observer,
 195                                        const CertificateShPtr& certificate,
 196                                        const CertificateShPtrVector& untrustedCertificates,
 197                                        const CertificateShPtrVector& trustedCertificates,
 198                                        bool useSystemTrustedCertificates)
 199 {
 200     m_impl->getCertChain(observer,
 201                          LogicCommand::GET_CHAIN_CERT,
 202                          certificate,
 203                          toRawBufferVector(untrustedCertificates),
 204                          toRawBufferVector(trustedCertificates),
 205                          useSystemTrustedCertificates);
 206 }
 207
 208 void ManagerAsync::getCertificateChain(const ObserverPtr& observer,
 209                                        const CertificateShPtr& certificate,
 210                                        const AliasVector& untrustedCertificates,
 211                                        const AliasVector& trustedCertificates,
 212                                        bool useSystemTrustedCertificates)
 213 {
 214     m_impl->getCertChain(observer,
 215                          LogicCommand::GET_CHAIN_ALIAS,
 216                          certificate,
 217                          toLabelNameVector(untrustedCertificates),
 218                          toLabelNameVector(trustedCertificates),
 219                          useSystemTrustedCertificates);
 220 }
 221
 222 void ManagerAsync::createSignature(const ObserverPtr& observer,
 223                                    const Alias& privateKeyAlias,
 224                                    const Password& password,
 225                                    const RawBuffer& message,
 226                                    const HashAlgorithm hash,
 227                                    const RSAPaddingAlgorithm padding)
 228 {
 229     m_impl->createSignature(observer, privateKeyAlias, password, message, hash, padding);
 230 }
 231
 232 void ManagerAsync::verifySignature(const ObserverPtr& observer,
 233                                    const Alias& publicKeyOrCertAlias,
 234                                    const Password& password,
 235                                    const RawBuffer& message,
 236                                    const RawBuffer& signature,
 237                                    const HashAlgorithm hash,
 238                                    const RSAPaddingAlgorithm padding)
 239 {
 240     m_impl->verifySignature(observer, publicKeyOrCertAlias, password, message, signature, hash, padding);
 241 }
 242
 243 void ManagerAsync::ocspCheck(const ObserverPtr& observer,
 244                              const CertificateShPtrVector& certificateChainVector)
 245 {
 246     m_impl->ocspCheck(observer, certificateChainVector);
 247 }
 248
 249 void ManagerAsync::setPermission(const ObserverPtr& observer,
 250                                  const Alias& alias,
 251                                  const Label& accessor,
 252                                  PermissionMask permissionMask)
 253 {
 254     m_impl->setPermission(observer, alias, accessor, permissionMask);
 255 }
 256
 257 } // namespace CKM
 258