src/manager/client/client-manager.cpp

   1 /*
   2  *  Copyright (c) 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        ckm-manager.cpp
  18  * @author      Bartlomiej Grzelewski (b.grzelewski@samsung.com)
  19  * @version     1.0
  20  * @brief       Manager implementation for client library.
  21  */
  22 #include <dpl/log/log.h>
  23
  24 #include <ckm/ckm-manager.h>
  25 #include <client-manager-impl.h>
  26
  27 namespace CKM {
  28
  29 Manager::Manager()
  30   : m_impl(new Impl())
  31 {}
  32
  33 Manager::~Manager(){}
  34
  35 int Manager::saveKey(const Alias &alias, const KeyShPtr &key, const Policy &policy) {
  36     return m_impl->saveKey(alias, key, policy);
  37 }
  38
  39 int Manager::saveCertificate(const Alias &alias, const CertificateShPtr &cert, const Policy &policy) {
  40     return m_impl->saveCertificate(alias, cert, policy);
  41 }
  42
  43 int Manager::savePKCS12(
  44     const Alias &alias,
  45     const PKCS12ShPtr &pkcs,
  46     const Policy &keyPolicy,
  47     const Policy &certPolicy)
  48 {
  49     return m_impl->savePKCS12(alias, pkcs, keyPolicy, certPolicy);
  50 }
  51
  52 int Manager::saveData(const Alias &alias, const RawBuffer &data, const Policy &policy) {
  53     return m_impl->saveData(alias, data, policy);
  54 }
  55
  56 int Manager::removeAlias(const Alias &alias) {
  57     return m_impl->removeAlias(alias);
  58 }
  59
  60 int Manager::getKey(const Alias &alias, const Password &password, KeyShPtr &key) {
  61     return m_impl->getKey(alias, password, key);
  62 }
  63
  64 int Manager::getCertificate(
  65     const Alias &alias,
  66     const Password &password,
  67     CertificateShPtr &certificate)
  68 {
  69     return m_impl->getCertificate(alias, password, certificate);
  70 }
  71
  72 int Manager::getData(const Alias &alias, const Password &password, RawBuffer &data) {
  73     return m_impl->getData(alias, password, data);
  74 }
  75
  76 int Manager::getPKCS12(const Alias &alias, PKCS12ShPtr &pkcs) {
  77     return m_impl->getPKCS12(alias, pkcs);
  78 }
  79
  80 int Manager::getPKCS12(
  81     const Alias &alias,
  82     const Password &keyPass,
  83     const Password &certPass,
  84     PKCS12ShPtr &pkcs)
  85 {
  86     return m_impl->getPKCS12(alias, keyPass, certPass, pkcs);
  87 }
  88
  89 int Manager::getKeyAliasVector(AliasVector &aliasVector) {
  90     return m_impl->getKeyAliasVector(aliasVector);
  91 }
  92
  93 int Manager::getCertificateAliasVector(AliasVector &aliasVector) {
  94     return m_impl->getCertificateAliasVector(aliasVector);
  95 }
  96
  97 int Manager::getDataAliasVector(AliasVector &aliasVector) {
  98     return m_impl->getDataAliasVector(aliasVector);
  99 }
 100
 101 int Manager::createKeyPairRSA(
 102     const int size,              // size in bits [1024, 2048, 4096]
 103     const Alias &privateKeyAlias,
 104     const Alias &publicKeyAlias,
 105     const Policy &policyPrivateKey,
 106     const Policy &policyPublicKey)
 107 {
 108     return m_impl->createKeyPairRSA(size, privateKeyAlias, publicKeyAlias, policyPrivateKey, policyPublicKey);
 109 }
 110
 111 int Manager::createKeyPairDSA(
 112     const int size,              // size in bits [1024, 2048, 3072, 4096]
 113     const Alias &privateKeyAlias,
 114     const Alias &publicKeyAlias,
 115     const Policy &policyPrivateKey,
 116     const Policy &policyPublicKey)
 117 {
 118     return m_impl->createKeyPairDSA(size, privateKeyAlias, publicKeyAlias, policyPrivateKey, policyPublicKey);
 119 }
 120
 121 int Manager::createKeyPairECDSA(
 122     const ElipticCurve type,
 123     const Alias &privateKeyAlias,
 124     const Alias &publicKeyAlias,
 125     const Policy &policyPrivateKey,
 126     const Policy &policyPublicKey)
 127 {
 128     return m_impl->createKeyPairECDSA(type, privateKeyAlias, publicKeyAlias, policyPrivateKey, policyPublicKey);
 129 }
 130
 131 int Manager::createKeyAES(
 132     const int size,
 133     const Alias &keyAlias,
 134     const Policy &policyKey)
 135 {
 136     return m_impl->createKeyAES(size, keyAlias, policyKey);
 137 }
 138
 139 int Manager::getCertificateChain(
 140     const CertificateShPtr &certificate,
 141     const CertificateShPtrVector &untrustedCertificates,
 142     const CertificateShPtrVector &trustedCertificates,
 143     bool useTrustedSystemCertificates,
 144     CertificateShPtrVector &certificateChainVector)
 145 {
 146     return m_impl->getCertificateChain(
 147         certificate,
 148         untrustedCertificates,
 149         trustedCertificates,
 150         useTrustedSystemCertificates,
 151         certificateChainVector);
 152 }
 153
 154 int Manager::getCertificateChain(
 155     const CertificateShPtr &certificate,
 156     const AliasVector &untrustedCertificates,
 157     const AliasVector &trustedCertificates,
 158     bool useTrustedSystemCertificates,
 159     CertificateShPtrVector &certificateChainVector)
 160 {
 161     return m_impl->getCertificateChain(
 162         certificate,
 163         untrustedCertificates,
 164         trustedCertificates,
 165         useTrustedSystemCertificates,
 166         certificateChainVector);
 167 }
 168
 169 int Manager::createSignature(
 170     const Alias &privateKeyAlias,
 171     const Password &password,
 172     const RawBuffer &message,
 173     const HashAlgorithm hash,
 174     const RSAPaddingAlgorithm padding,
 175     RawBuffer &signature)
 176 {
 177     CryptoAlgorithm cAlg;
 178     cAlg.setParam(ParamName::SV_HASH_ALGO, hash);
 179     cAlg.setParam(ParamName::SV_RSA_PADDING, padding);
 180     return m_impl->createSignature(
 181         privateKeyAlias,
 182         password,
 183         message,
 184         cAlg,
 185         signature);
 186 }
 187
 188 int Manager::verifySignature(
 189     const Alias &publicKeyOrCertAlias,
 190     const Password &password,           // password for public_key (optional)
 191     const RawBuffer &message,
 192     const RawBuffer &signature,
 193     const HashAlgorithm hash,
 194     const RSAPaddingAlgorithm padding)
 195 {
 196     CryptoAlgorithm cAlg;
 197     cAlg.setParam(ParamName::SV_HASH_ALGO, hash);
 198     cAlg.setParam(ParamName::SV_RSA_PADDING, padding);
 199     return m_impl->verifySignature(
 200         publicKeyOrCertAlias,
 201         password,
 202         message,
 203         signature,
 204         cAlg);
 205 }
 206
 207 int Manager::ocspCheck(const CertificateShPtrVector &certificateChainVector, int &ocspStatus) {
 208     return m_impl->ocspCheck(certificateChainVector, ocspStatus);
 209 }
 210
 211 int Manager::setPermission(
 212     const Alias &alias,
 213     const Label &accessor,
 214     PermissionMask permissionMask)
 215 {
 216     return m_impl->setPermission(alias, accessor, permissionMask);
 217 }
 218
 219 int Manager::encrypt(
 220     const CryptoAlgorithm &algo,
 221     const Alias &keyAlias,
 222     const Password &password,
 223     const RawBuffer& plain,
 224     RawBuffer& encrypted)
 225 {
 226     return m_impl->encrypt(algo, keyAlias, password, plain, encrypted);
 227 }
 228
 229 int Manager::decrypt(
 230     const CryptoAlgorithm &algo,
 231     const Alias &keyAlias,
 232     const Password &password,
 233     const RawBuffer& encrypted,
 234     RawBuffer& decrypted)
 235 {
 236     return m_impl->decrypt(algo, keyAlias, password, encrypted, decrypted);
 237 }
 238
 239 ManagerShPtr Manager::create() {
 240     try {
 241         return std::make_shared<Manager>();
 242     } catch (const std::bad_alloc &) {
 243         LogDebug("Bad alloc was caught during Manager::Impl creation.");
 244     } catch (...) {
 245         LogError("Critical error: Unknown exception was caught during Manager::Impl creation!");
 246     }
 247     return ManagerShPtr();
 248 }
 249
 250 } // namespace CKM
 251