src/include/ckm/ckm-manager-async.h

   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        ckm-manager-async.h
  18  * @author      Bartlomiej Grzelewski (b.grzelewski@samsung.com)
  19  * @version     1.0
  20  * @brief       Async key manager API.
  21  */
  22 #pragma once
  23
  24 #include <memory>
  25
  26 #include <ckm/ckm-certificate.h>
  27 #include <ckm/ckm-error.h>
  28 #include <ckm/ckm-key.h>
  29 #include <ckm/ckm-type.h>
  30 #include <ckm/ckm-pkcs12.h>
  31
  32 // Central Key Manager namespace
  33 namespace CKM {
  34
  35 // Asynchronous interface to Central Key Manager. This implementation uses
  36 // internal thread for connection. Key Manager is not thread safe.
  37 class KEY_MANAGER_API ManagerAsync
  38 {
  39 public:
  40     class Impl;
  41
  42     ManagerAsync();
  43
  44     ManagerAsync(const ManagerAsync&) = delete;
  45     ManagerAsync& operator=(const ManagerAsync&) = delete;
  46
  47     // Observer will observer custom operation.
  48     struct Observer {
  49         virtual void ReceivedError(int error) = 0;
  50
  51         virtual void ReceivedSaveKey() {}
  52         virtual void ReceivedSaveCertificate() {}
  53         virtual void ReceivedSaveData() {}
  54         virtual void ReceivedSavePKCS12() {}
  55
  56         virtual void ReceivedRemovedAlias() {}
  57
  58         virtual void ReceivedKey(Key &&) {}
  59         virtual void ReceivedCertificate(Certificate &&) {}
  60         virtual void ReceivedData(RawBuffer &&) {}
  61         virtual void ReceivedPKCS12(PKCS12ShPtr &&) {}
  62
  63         virtual void ReceivedKeyAliasVector(AliasVector &&) {}
  64         virtual void ReceivedCertificateAliasVector(AliasVector &&) {}
  65         virtual void ReceivedDataAliasVector(AliasVector &&) {}
  66
  67         virtual void ReceivedCreateKeyPair() {}
  68
  69         virtual void ReceivedGetCertificateChain(CertificateShPtrVector &&) {}
  70
  71         virtual void ReceivedCreateSignature(RawBuffer &&) {}
  72         virtual void ReceivedVerifySignature() {}
  73
  74         virtual void ReceivedOCSPCheck(int) {}
  75
  76         virtual void ReceivedSetPermission() {}
  77
  78         virtual ~Observer() {}
  79     };
  80
  81     typedef std::shared_ptr<Observer> ObserverPtr;
  82
  83     virtual ~ManagerAsync();
  84
  85     void saveKey(
  86             const ObserverPtr& observer,
  87             const Alias& alias,
  88             const KeyShPtr& key,
  89             const Policy& policy);
  90     void saveCertificate(
  91             const ObserverPtr& observer,
  92             const Alias& alias,
  93             const CertificateShPtr& cert,
  94             const Policy& policy);
  95     void saveData(
  96             const ObserverPtr& observer,
  97             const Alias& alias,
  98             const RawBuffer& data,
  99             const Policy& policy);
 100     void savePKCS12(
 101             const ObserverPtr& observer,
 102             const Alias &alias,
 103             const PKCS12ShPtr &pkcs,
 104             const Policy &keyPolicy,
 105             const Policy &certPolicy);
 106
 107     void removeAlias(const ObserverPtr& observer, const Alias& alias);
 108
 109     void getKey(const ObserverPtr& observer, const Alias& alias, const Password& password);
 110     void getCertificate(const ObserverPtr& observer, const Alias& alias, const Password& password);
 111     void getData(const ObserverPtr& observer, const Alias& alias, const Password& password);
 112
 113     void getPKCS12(
 114         const ObserverPtr& observer,
 115         const Alias &alias,
 116         const Password& passwordKey = Password(),
 117         const Password& passwordCert = Password());
 118
 119     // send request for list of all keys/certificates/data that application/user may use
 120     void getKeyAliasVector(const ObserverPtr& observer);
 121     void getCertificateAliasVector(const ObserverPtr& observer);
 122     void getDataAliasVector(const ObserverPtr& observer);
 123
 124     void createKeyPairRSA(
 125             const ObserverPtr& observer,
 126             int size,
 127             const Alias& privateKeyAlias,
 128             const Alias& publicKeyAlias,
 129             const Policy& policyPrivateKey = Policy(),
 130             const Policy& policyPublicKey = Policy());
 131     void createKeyPairDSA(
 132             const ObserverPtr& observer,
 133             int size,
 134             const Alias& privateKeyAlias,
 135             const Alias& publicKeyAlias,
 136             const Policy& policyPrivateKey = Policy(),
 137             const Policy& policyPublicKey = Policy());
 138     void createKeyPairECDSA(
 139             const ObserverPtr& observer,
 140             const ElipticCurve type,
 141             const Alias& privateKeyAlias,
 142             const Alias& publicKeyAlias,
 143             const Policy& policyPrivateKey = Policy(),
 144             const Policy& policyPublicKey = Policy());
 145     void createKeyAES(
 146             const ObserverPtr& observer,
 147             int size,
 148             const Alias &keyAlias,
 149             const Policy &policyKey = Policy());
 150
 151     void getCertificateChain(
 152             const ObserverPtr& observer,
 153             const CertificateShPtr& certificate,
 154             const CertificateShPtrVector& untrustedCertificates,
 155             const CertificateShPtrVector& trustedCertificates,
 156             bool useSystemTrustedCertificates);
 157     void getCertificateChain(
 158             const ObserverPtr& observer,
 159             const CertificateShPtr& certificate,
 160             const AliasVector& untrustedCertificates,
 161             const AliasVector& trustedCertificates,
 162             bool useSystemTrustedCertificates);
 163
 164     void createSignature(
 165             const ObserverPtr& observer,
 166             const Alias& privateKeyAlias,
 167             const Password& password,           // password for private_key
 168             const RawBuffer& message,
 169             const HashAlgorithm hash,
 170             const RSAPaddingAlgorithm padding);
 171     void verifySignature(
 172             const ObserverPtr& observer,
 173             const Alias& publicKeyOrCertAlias,
 174             const Password& password,           // password for public_key (optional)
 175             const RawBuffer& message,
 176             const RawBuffer& signature,
 177             const HashAlgorithm hash,
 178             const RSAPaddingAlgorithm padding);
 179
 180     // This function will check all certificates in chain except Root CA.
 181     // This function will delegate task to service. You may use this even
 182     // if application does not have permission to use network.
 183     void ocspCheck(
 184             const ObserverPtr& observer,
 185             const CertificateShPtrVector& certificateChainVector);
 186
 187     void setPermission(
 188             const ObserverPtr& observer,
 189             const Alias& alias,
 190             const Label& accessor,
 191             PermissionMask permissionMask);
 192
 193 private:
 194     std::unique_ptr<Impl> m_impl;
 195 };
 196
 197 } // namespace CKM
 198