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 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 ReceivedCreateKeyPairRSA() {}
  68         virtual void ReceivedCreateKeyPairDSA() {}
  69         virtual void ReceivedCreateKeyPairECDSA() {}
  70
  71         virtual void ReceivedGetCertificateChain(CertificateShPtrVector &&) {}
  72
  73         virtual void ReceivedCreateSignature(RawBuffer &&) {}
  74         virtual void ReceivedVerifySignature() {}
  75
  76         virtual void ReceivedOCSPCheck(int) {}
  77
  78         virtual void ReceivedSetPermission() {}
  79
  80         virtual ~Observer() {}
  81     };
  82
  83     typedef std::shared_ptr<Observer> ObserverPtr;
  84
  85     virtual ~ManagerAsync();
  86
  87     void saveKey(
  88             const ObserverPtr& observer,
  89             const Alias& alias,
  90             const KeyShPtr& key,
  91             const Policy& policy);
  92     void saveCertificate(
  93             const ObserverPtr& observer,
  94             const Alias& alias,
  95             const CertificateShPtr& cert,
  96             const Policy& policy);
  97     void saveData(
  98             const ObserverPtr& observer,
  99             const Alias& alias,
 100             const RawBuffer& data,
 101             const Policy& policy);
 102     void savePKCS12(
 103             const ObserverPtr& observer,
 104             const Alias &alias,
 105             const PKCS12ShPtr &pkcs,
 106             const Policy &keyPolicy,
 107             const Policy &certPolicy);
 108
 109     void removeAlias(const ObserverPtr& observer, const Alias& alias);
 110
 111     void getKey(const ObserverPtr& observer, const Alias& alias, const Password& password);
 112     void getCertificate(const ObserverPtr& observer, const Alias& alias, const Password& password);
 113     void getData(const ObserverPtr& observer, const Alias& alias, const Password& password);
 114     void getPKCS12(const ObserverPtr& observer, const Alias &alias);
 115
 116     // send request for list of all keys/certificates/data that application/user may use
 117     void getKeyAliasVector(const ObserverPtr& observer);
 118     void getCertificateAliasVector(const ObserverPtr& observer);
 119     void getDataAliasVector(const ObserverPtr& observer);
 120
 121     void createKeyPairRSA(
 122             const ObserverPtr& observer,
 123             int size,
 124             const Alias& privateKeyAlias,
 125             const Alias& publicKeyAlias,
 126             const Policy& policyPrivateKey = Policy(),
 127             const Policy& policyPublicKey = Policy());
 128     void createKeyPairDSA(
 129             const ObserverPtr& observer,
 130             int size,
 131             const Alias& privateKeyAlias,
 132             const Alias& publicKeyAlias,
 133             const Policy& policyPrivateKey = Policy(),
 134             const Policy& policyPublicKey = Policy());
 135     void createKeyPairECDSA(
 136             const ObserverPtr& observer,
 137             const ElipticCurve type,
 138             const Alias& privateKeyAlias,
 139             const Alias& publicKeyAlias,
 140             const Policy& policyPrivateKey = Policy(),
 141             const Policy& policyPublicKey = Policy());
 142
 143     void getCertificateChain(
 144             const ObserverPtr& observer,
 145             const CertificateShPtr& certificate,
 146             const CertificateShPtrVector& untrustedCertificates);
 147     void getCertificateChain(
 148             const ObserverPtr& observer,
 149             const CertificateShPtr& certificate,
 150             const AliasVector& untrustedCertificates);
 151
 152     void createSignature(
 153             const ObserverPtr& observer,
 154             const Alias& privateKeyAlias,
 155             const Password& password,           // password for private_key
 156             const RawBuffer& message,
 157             const HashAlgorithm hash,
 158             const RSAPaddingAlgorithm padding);
 159     void verifySignature(
 160             const ObserverPtr& observer,
 161             const Alias& publicKeyOrCertAlias,
 162             const Password& password,           // password for public_key (optional)
 163             const RawBuffer& message,
 164             const RawBuffer& signature,
 165             const HashAlgorithm hash,
 166             const RSAPaddingAlgorithm padding);
 167
 168     // This function will check all certificates in chain except Root CA.
 169     // This function will delegate task to service. You may use this even
 170     // if application does not have permission to use network.
 171     void ocspCheck(
 172             const ObserverPtr& observer,
 173             const CertificateShPtrVector& certificateChainVector);
 174
 175     void setPermission(
 176             const ObserverPtr& observer,
 177             const Alias& alias,
 178             const Label& accessor,
 179             Permission newPermission);
 180
 181 private:
 182     std::unique_ptr<Impl> m_impl;
 183 };
 184
 185 } // namespace CKM
 186