Async API stubs

Change-Id: I3d91fa6506fdab315826312bf02253093b12f049

4 files changed, 522 insertions, 97 deletions

diff --git a/src/include/ckm/ckm-manager-async.h b/src/include/ckm/ckm-manager-async.h
index a6dcc3d8..cb3ce89f 100644
--- a/src/include/ckm/ckm-manager-async.h
+++ b/src/include/ckm/ckm-manager-async.h
@@ -45,47 +45,37 @@ public:
 
     // Observer will observer custom operation.
     struct Observer {
-        // Error callback - all errors
-        // ERROR_API_NOT_SUPPORTED,
-        // ERROR_API_CONNECTION_LOST,
-        // ERROR_API_PARSING_ERROR,
-        // ERROR_API_ALIAS_UNKNOWN
         virtual void ReceivedError(int error) = 0;
 
         virtual void ReceivedSaveKey() {}
-
-        // This will return data
-        /*
-        virtual void ReceivedKey(Key && key) {}
-        virtual void ReceivedCertificate(Certificate && certificate) {}
-        virtual void ReceivedKeyAliasVector(AliasVector && aliasVector) {}
-        virtual void ReceivedCertificateAliasVector(AliasVector && aliasVector) {}
-
-        // This callbacks will confirm successful operation
         virtual void ReceivedSaveCertificate() {}
+        virtual void ReceivedSaveData() {}
+
         virtual void ReceivedRemovedKey() {}
         virtual void ReceivedRemovedCertificate() {}
+        virtual void ReceivedRemovedData() {}
 
-        // Added By Dongsun Lee
-        virtual void ReceivedData(RawBuffer && data) {}
-        virtual void ReceivedDataAliasVector(AliasVector && aliasVector) {}
+        virtual void ReceivedKey(Key &&) {}
+        virtual void ReceivedCertificate(Certificate &&) {}
+        virtual void ReceivedData(RawBuffer &&) {}
+
+        virtual void ReceivedKeyAliasVector(AliasVector &&) {}
+        virtual void ReceivedCertificateAliasVector(AliasVector &&) {}
+        virtual void ReceivedDataAliasVector(AliasVector &&) {}
 
-        // This callbacks will confirm successful operation
-        virtual void ReceivedSaveData() {}
-        virtual void ReceivedRemovedData() {}
         virtual void ReceivedCreateKeyPairRSA() {}
+        virtual void ReceivedCreateKeyPairDSA() {}
         virtual void ReceivedCreateKeyPairECDSA() {}
-        virtual void ReceivedCreateSignature(RawBuffer && signature) {}
 
-        // TODO: describe status
+        virtual void ReceivedGetCertificateChain(CertificateShPtrVector &&) {}
+
+        virtual void ReceivedCreateSignature(RawBuffer &&) {}
         virtual void ReceivedVerifySignature() {}
-        // TODO: describe status
-        // Do we need some chain of the certificate?
-        virtual void ReceivedVerifyCertificate() {}
 
-        virtual void ReceivedGetCertiticateChain(CertificateShPtrVector &&certificateVector) {}
-        virtual void ReceivedStrictCACheck();
-        virtual void ReceivedOCSPCheck();*/
+        virtual void ReceivedOCSPCheck(int) {}
+
+        virtual void ReceivedAllowAccess() {}
+        virtual void ReceivedDenyAccess() {}
 
         virtual ~Observer() {}
     };
@@ -94,85 +84,102 @@ public:
 
     virtual ~ManagerAsync();
 
-    void saveKey(const ObserverPtr& observer, const Alias& alias, const KeyShPtr& key, const Policy& policy);
-
-    /*
-    void saveCertificate(Observer *observer, const Alias &alias, const Certificate &cert, const Policy &policy);
-
-    void removeKey(Observer *observer, const Alias &alias);
-    void removeCertificate(Observer *observer, const Alias &alias);
-
-    void requestKey(Observer *observer, const Alias &alias);
-    void requestCertificate(Observer *observer, const Alias &alias);
-
-    // This will extract list of all Keys and Certificates in Key Store
-    void requestKeyAliasVector(Observer *observer);         // send request for list of all keys that application/user may use
-    void requestCertificateAliasVector(Observer *observer); // send request for list of all certs that application/user may use
-
-    // Added By Dongsun Lee
-    void saveData(Observer *observer, const Alias &alias, const RawBuffer &data, const Policy &policy);
-    void removeData(Observer *observer, const Alias &alias);
-    void requestData(Observer *observer, const Alias &alias);
-    void requestDataAliasVector(Observer *observer);  // send request for list of all data that application/user may use
-    void createKeyPairRSA(Observer *observer, const Alias &privateKeyAlias, const Alias &publicKeyAlias, const int &size, const Policy &policy);
-    void createKeyPairECDSA(Observer *observer, const Alias &privateKeyAlias, const Alias &publicKeyAlias, ECType type, const int &size, const Policy &policy);
-    void createSignature(Observer *observer, const Alias &privateKeyAlias, const RawBuffer &password, const RawBuffer &message);
-    void verifySignature(Observer *observer, const Alias &publicKeyOrCertAlias, const RawBuffer &password, const RawBuffer &message, const RawBuffer &signature);
-
-    // Should we use also certificates stored by user in Certral Key Manager?
-    // Sometimes we may want to verify certificate without OCSP (for example we are installing side-loaded app and network is not working).
-    void verifyCertificate(Observer *observer, const Certificate &certificate, const CertificateShPtrVector &untrusted, const bool ocspCheck, const bool strictCaFlagCheck);
+    void saveKey(
+            const ObserverPtr& observer,
+            const Alias& alias,
+            const KeyShPtr& key,
+            const Policy& policy);
+    void saveCertificate(
+            const ObserverPtr& observer,
+            const Alias& alias,
+            const CertificateShPtr& cert,
+            const Policy& policy);
+    void saveData(
+            const ObserverPtr& observer,
+            const Alias& alias,
+            const RawBuffer& data,
+            const Policy& policy);
+
+    void removeKey(const ObserverPtr& observer, const Alias& alias);
+    void removeCertificate(const ObserverPtr& observer, const Alias& alias);
+    void removeData(const ObserverPtr& observer, const Alias& alias);
+
+    void getKey(const ObserverPtr& observer, const Alias& alias, const Password& password);
+    void getCertificate(const ObserverPtr& observer, const Alias& alias, const Password& password);
+    void getData(const ObserverPtr& observer, const Alias& alias, const Password& password);
+
+    // send request for list of all keys/certificates/data that application/user may use
+    void getKeyAliasVector(const ObserverPtr& observer);
+    void getCertificateAliasVector(const ObserverPtr& observer);
+    void getDataAliasVector(const ObserverPtr& observer);
 
     void createKeyPairRSA(
-    Observer *observer,
-    const int size,              // size in bits [1024, 2048, 4096]
-    const Alias &privateKeyAlias,
-    const Alias &publicKeyAlias,
-    const Policy &policyPrivateKey = Policy(),
-    const Policy &policyPublicKey = Policy());
-
+            const ObserverPtr& observer,
+            int size,
+            const Alias& privateKeyAlias,
+            const Alias& publicKeyAlias,
+            const Policy& policyPrivateKey = Policy(),
+            const Policy& policyPublicKey = Policy());
+    void createKeyPairDSA(
+            const ObserverPtr& observer,
+            int size,
+            const Alias& privateKeyAlias,
+            const Alias& publicKeyAlias,
+            const Policy& policyPrivateKey = Policy(),
+            const Policy& policyPublicKey = Policy());
     void createKeyPairECDSA(
-    Observer *observer,
-    const Key::ECType type,
-    const Alias &privateKeyAlias,
-    const Alias &publicKeyAlias,
-    const Policy &policyPrivateKey = Policy(),
-    const Policy &policyPublicKey = Policy());
-
-    // this fuction will return chains of certificates and check it with openssl
-    // status : OK, INCOMPLETE_CHAIN, VERIFICATION_FAILED
-    void getCertiticateChain(
-    const Certificate &certificate,
-    const CertificateShPtrVector &untrustedCertificates);
+            const ObserverPtr& observer,
+            const ElipticCurve type,
+            const Alias& privateKeyAlias,
+            const Alias& publicKeyAlias,
+            const Policy& policyPrivateKey = Policy(),
+            const Policy& policyPublicKey = Policy());
 
     void getCertificateChain(
-    const Certificate &certificate,
-    const AliasVector &untrustedCertificates);
-
-    void strictCACheck(const CertificateShPtrVector &certificateVector);
+            const ObserverPtr& observer,
+            const CertificateShPtr& certificate,
+            const CertificateShPtrVector& untrustedCertificates);
+    void getCertificateChain(
+            const ObserverPtr& observer,
+            const CertificateShPtr& certificate,
+            const AliasVector& untrustedCertificates);
+
+    void createSignature(
+            const ObserverPtr& observer,
+            const Alias& privateKeyAlias,
+            const Password& password,           // password for private_key
+            const RawBuffer& message,
+            const HashAlgorithm hash,
+            const RSAPaddingAlgorithm padding);
+    void verifySignature(
+            const ObserverPtr& observer,
+            const Alias& publicKeyOrCertAlias,
+            const Password& password,           // password for public_key (optional)
+            const RawBuffer& message,
+            const RawBuffer& signature,
+            const HashAlgorithm hash,
+            const RSAPaddingAlgorithm padding);
 
     // This function will check all certificates in chain except Root CA.
-    void ocspCheck(const CertificateShPtrVector &certificateChainVector);*/
+    // This function will delegate task to service. You may use this even
+    // if application does not have permission to use network.
+    void ocspCheck(
+            const ObserverPtr& observer,
+            const CertificateShPtrVector& certificateChainVector);
+
+    void allowAccess(
+            const ObserverPtr& observer,
+            const std::string& alias,
+            const std::string& accessor,
+            AccessRight granted);
+    void denyAccess(
+            const ObserverPtr& observer,
+            const std::string& alias,
+            const std::string& accessor);
 
 private:
     std::unique_ptr<Impl> m_impl;
 };
 
-// Out of scope
-/*
- class ManagerAsyncNoThread : public ManagerAsync {
- public:
-     ManagerAsyncNoThread();
-     ManagerAsyncNoThread(const ConnectionAsyncNoThread &);
-     ManagerAsyncNoThread(ConnectionAsyncNoThread &&);
-     ManagerAsyncNoThread& operator=(const ConnectionAsyncNoThread &);
-     ManagerAsyncNoThread& operator=(ConnectionAsyncNoThread &&);
-     virtual ~ConnecitonAsyncNoThread() {}
-
-     int getDesc();          // extract descriptor number
-     int processDesc();      // send request and receive data from central key manager
-     };
- */
-
 } // namespace CKM
 
diff --git a/src/manager/client-async/client-manager-async-impl.cpp b/src/manager/client-async/client-manager-async-impl.cpp
index 744e3a27..5e991c5d 100644
--- a/src/manager/client-async/client-manager-async-impl.cpp
+++ b/src/manager/client-async/client-manager-async-impl.cpp
@@ -51,6 +51,171 @@ void ManagerAsync::Impl::saveKey(const ManagerAsync::ObserverPtr& observer,
     saveBinaryData(observer, alias, toDBDataType(key->getType()), key->getDER(), policy);
 }
 
+void ManagerAsync::Impl::saveCertificate(const ObserverPtr& observer,
+                                         const Alias& /*alias*/,
+                                         const CertificateShPtr& /*cert*/,
+                                         const Policy& /*policy*/)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+void ManagerAsync::Impl::saveData(const ObserverPtr& observer,
+                                  const Alias& /*alias*/,
+                                  const RawBuffer& /*data*/,
+                                  const Policy& /*policy*/)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+
+void ManagerAsync::Impl::removeKey(const ObserverPtr& observer, const Alias& /*alias*/)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+void ManagerAsync::Impl::removeCertificate(const ObserverPtr& observer, const Alias& /*alias*/)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+void ManagerAsync::Impl::removeData(const ObserverPtr& observer, const Alias& /*alias*/)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+
+void ManagerAsync::Impl::getKey(const ObserverPtr& observer,
+                                const Alias& /*alias*/,
+                                const Password& /*password*/)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+void ManagerAsync::Impl::getCertificate(const ObserverPtr& observer,
+                                        const Alias& /*alias*/,
+                                        const Password& /*password*/)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+void ManagerAsync::Impl::getData(const ObserverPtr& observer,
+                                 const Alias& /*alias*/,
+                                 const Password& /*password*/)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+
+void ManagerAsync::Impl::getKeyAliasVector(const ObserverPtr& observer)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+void ManagerAsync::Impl::getCertificateAliasVector(const ObserverPtr& observer)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+void ManagerAsync::Impl::getDataAliasVector(const ObserverPtr& observer)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+
+void ManagerAsync::Impl::createKeyPairRSA(const ObserverPtr& observer,
+                                          int /*size*/,
+                                          const Alias& /*privateKeyAlias*/,
+                                          const Alias& /*publicKeyAlias*/,
+                                          const Policy& /*policyPrivateKey*/,
+                                          const Policy& /*policyPublicKey*/)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+void ManagerAsync::Impl::createKeyPairDSA(const ObserverPtr& observer,
+                                          int /*size*/,
+                                          const Alias& /*privateKeyAlias*/,
+                                          const Alias& /*publicKeyAlias*/,
+                                          const Policy& /*policyPrivateKey*/,
+                                          const Policy& /*policyPublicKey*/)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+void ManagerAsync::Impl::createKeyPairECDSA(const ObserverPtr& observer,
+                                            const ElipticCurve /*type*/,
+                                            const Alias& /*privateKeyAlias*/,
+                                            const Alias& /*publicKeyAlias*/,
+                                            const Policy& /*policyPrivateKey*/,
+                                            const Policy& /*policyPublicKey*/)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+
+void ManagerAsync::Impl::getCertificateChain(const ObserverPtr& observer,
+                                             const CertificateShPtr& /*certificate*/,
+                                             const CertificateShPtrVector& /*untrustedCertificates*/)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+
+void ManagerAsync::Impl::getCertificateChain(const ObserverPtr& observer,
+                                             const CertificateShPtr& /*certificate*/,
+                                             const AliasVector& /*untrustedCertificates*/)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+
+void ManagerAsync::Impl::createSignature(const ObserverPtr& observer,
+                                         const Alias& /*privateKeyAlias*/,
+                                         const Password& /*password*/,
+                                         const RawBuffer& /*message*/,
+                                         const HashAlgorithm /*hash*/,
+                                         const RSAPaddingAlgorithm /*padding*/)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+
+void ManagerAsync::Impl::verifySignature(const ObserverPtr& observer,
+                                         const Alias& /*publicKeyOrCertAlias*/,
+                                         const Password& /*password*/,
+                                         const RawBuffer& /*message*/,
+                                         const RawBuffer& /*signature*/,
+                                         const HashAlgorithm /*hash*/,
+                                         const RSAPaddingAlgorithm /*padding*/)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+
+void ManagerAsync::Impl::ocspCheck(const ObserverPtr& observer,
+                                   const CertificateShPtrVector& /*certificateChainVector*/)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+
+void ManagerAsync::Impl::allowAccess(const ObserverPtr& observer,
+                                     const std::string& /*alias*/,
+                                     const std::string& /*accessor*/,
+                                     AccessRight /*granted*/)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+
+void ManagerAsync::Impl::denyAccess(const ObserverPtr& observer,
+                                    const std::string& /*alias*/,
+                                    const std::string& /*accessor*/)
+{
+    observerCheck(observer);
+    observer->ReceivedError(CKM_API_ERROR_UNKNOWN);
+}
+
 void ManagerAsync::Impl::saveBinaryData(const ManagerAsync::ObserverPtr& observer,
                                         const Alias& alias,
                                         DBDataType dataType,
diff --git a/src/manager/client-async/client-manager-async-impl.h b/src/manager/client-async/client-manager-async-impl.h
index e3fde09e..d16593fc 100644
--- a/src/manager/client-async/client-manager-async-impl.h
+++ b/src/manager/client-async/client-manager-async-impl.h
@@ -38,7 +38,94 @@ public:
 
     virtual ~Impl();
 
-    void saveKey(const ManagerAsync::ObserverPtr&, const Alias&, const KeyShPtr&, const Policy&);
+    void saveKey(
+            const ObserverPtr& observer,
+            const Alias& alias,
+            const KeyShPtr& key,
+            const Policy& policy);
+    void saveCertificate(
+            const ObserverPtr& observer,
+            const Alias& alias,
+            const CertificateShPtr& cert,
+            const Policy& policy);
+    void saveData(
+            const ObserverPtr& observer,
+            const Alias& alias,
+            const RawBuffer& data,
+            const Policy& policy);
+
+    void removeKey(const ObserverPtr& observer, const Alias& alias);
+    void removeCertificate(const ObserverPtr& observer, const Alias& alias);
+    void removeData(const ObserverPtr& observer, const Alias& alias);
+
+    void getKey(const ObserverPtr& observer, const Alias& alias, const Password& password);
+    void getCertificate(const ObserverPtr& observer, const Alias& alias, const Password& password);
+    void getData(const ObserverPtr& observer, const Alias& alias, const Password& password);
+
+    void getKeyAliasVector(const ObserverPtr& observer);
+    void getCertificateAliasVector(const ObserverPtr& observer);
+    void getDataAliasVector(const ObserverPtr& observer);
+
+    void createKeyPairRSA(
+            const ObserverPtr& observer,
+            int size,
+            const Alias& privateKeyAlias,
+            const Alias& publicKeyAlias,
+            const Policy& policyPrivateKey,
+            const Policy& policyPublicKey);
+    void createKeyPairDSA(
+            const ObserverPtr& observer,
+            int size,
+            const Alias& privateKeyAlias,
+            const Alias& publicKeyAlias,
+            const Policy& policyPrivateKey,
+            const Policy& policyPublicKey);
+    void createKeyPairECDSA(
+            const ObserverPtr& observer,
+            const ElipticCurve type,
+            const Alias& privateKeyAlias,
+            const Alias& publicKeyAlias,
+            const Policy& policyPrivateKey,
+            const Policy& policyPublicKey);
+
+    void getCertificateChain(
+            const ObserverPtr& observer,
+            const CertificateShPtr& certificate,
+            const CertificateShPtrVector& untrustedCertificates);
+    void getCertificateChain(
+            const ObserverPtr& observer,
+            const CertificateShPtr& certificate,
+            const AliasVector& untrustedCertificates);
+
+    void createSignature(
+            const ObserverPtr& observer,
+            const Alias& privateKeyAlias,
+            const Password& password,
+            const RawBuffer& message,
+            const HashAlgorithm hash,
+            const RSAPaddingAlgorithm padding);
+    void verifySignature(
+            const ObserverPtr& observer,
+            const Alias& publicKeyOrCertAlias,
+            const Password& password,
+            const RawBuffer& message,
+            const RawBuffer& signature,
+            const HashAlgorithm hash,
+            const RSAPaddingAlgorithm padding);
+
+    void ocspCheck(
+            const ObserverPtr& observer,
+            const CertificateShPtrVector& certificateChainVector);
+
+    void allowAccess(
+            const ObserverPtr& observer,
+            const std::string& alias,
+            const std::string& accessor,
+            AccessRight granted);
+    void denyAccess(
+            const ObserverPtr& observer,
+            const std::string& alias,
+            const std::string& accessor);
 
 private:
     void saveBinaryData(const ManagerAsync::ObserverPtr& observer,
diff --git a/src/manager/client-async/client-manager-async.cpp b/src/manager/client-async/client-manager-async.cpp
index 85f376f4..7c747bf2 100644
--- a/src/manager/client-async/client-manager-async.cpp
+++ b/src/manager/client-async/client-manager-async.cpp
@@ -42,5 +42,171 @@ void ManagerAsync::saveKey(const ObserverPtr& observer,
     m_impl->saveKey(observer, alias, key, policy);
 }
 
+void ManagerAsync::saveCertificate(const ObserverPtr& observer,
+                                   const Alias& alias,
+                                   const CertificateShPtr& cert,
+                                   const Policy& policy)
+{
+    m_impl->saveCertificate(observer, alias, cert, policy);
+}
+
+void ManagerAsync::saveData(const ObserverPtr& observer,
+                            const Alias& alias,
+                            const RawBuffer& data,
+                            const Policy& policy)
+{
+    m_impl->saveData(observer, alias, data, policy);
+}
+
+void ManagerAsync::removeKey(const ObserverPtr& observer, const Alias& alias)
+{
+    m_impl->removeKey(observer, alias);
+}
+
+void ManagerAsync::removeCertificate(const ObserverPtr& observer, const Alias& alias)
+{
+    m_impl->removeCertificate(observer, alias);
+}
+
+void ManagerAsync::removeData(const ObserverPtr& observer, const Alias& alias)
+{
+    m_impl->removeData(observer, alias);
+}
+
+void ManagerAsync::getKey(const ObserverPtr& observer, const Alias& alias, const Password& password)
+{
+    m_impl->getKey(observer, alias, password);
+}
+
+void ManagerAsync::getCertificate(const ObserverPtr& observer,
+                                  const Alias& alias,
+                                  const Password& password)
+{
+    m_impl->getCertificate(observer, alias, password);
+}
+
+void ManagerAsync::getData(const ObserverPtr& observer,
+                           const Alias& alias,
+                           const Password& password)
+{
+    m_impl->getData(observer, alias, password);
+}
+
+void ManagerAsync::getKeyAliasVector(const ObserverPtr& observer)
+{
+    m_impl->getKeyAliasVector(observer);
+}
+
+void ManagerAsync::getCertificateAliasVector(const ObserverPtr& observer)
+{
+    m_impl->getCertificateAliasVector(observer);
+}
+
+void ManagerAsync::getDataAliasVector(const ObserverPtr& observer)
+{
+    m_impl->getDataAliasVector(observer);
+}
+
+void ManagerAsync::createKeyPairRSA(const ObserverPtr& observer,
+                                    int size,
+                                    const Alias& privateKeyAlias,
+                                    const Alias& publicKeyAlias,
+                                    const Policy& policyPrivateKey,
+                                    const Policy& policyPublicKey)
+{
+    m_impl->createKeyPairRSA(observer,
+                             size,
+                             privateKeyAlias,
+                             publicKeyAlias,
+                             policyPrivateKey,
+                             policyPublicKey);
+}
+
+void ManagerAsync::createKeyPairDSA(const ObserverPtr& observer,
+                                    int size,
+                                    const Alias& privateKeyAlias,
+                                    const Alias& publicKeyAlias,
+                                    const Policy& policyPrivateKey,
+                                    const Policy& policyPublicKey)
+{
+    m_impl->createKeyPairDSA(observer,
+                             size,
+                             privateKeyAlias,
+                             publicKeyAlias,
+                             policyPrivateKey,
+                             policyPublicKey);
+}
+
+void ManagerAsync::createKeyPairECDSA(const ObserverPtr& observer,
+                                      const ElipticCurve type,
+                                      const Alias& privateKeyAlias,
+                                      const Alias& publicKeyAlias,
+                                      const Policy& policyPrivateKey,
+                                      const Policy& policyPublicKey)
+{
+    m_impl->createKeyPairECDSA(observer,
+                               type,
+                               privateKeyAlias,
+                               publicKeyAlias,
+                               policyPrivateKey,
+                               policyPublicKey);
+}
+
+void ManagerAsync::getCertificateChain(const ObserverPtr& observer,
+                                       const CertificateShPtr& certificate,
+                                       const CertificateShPtrVector& untrustedCertificates)
+{
+    m_impl->getCertificateChain(observer, certificate, untrustedCertificates);
+}
+
+void ManagerAsync::getCertificateChain(const ObserverPtr& observer,
+                                       const CertificateShPtr& certificate,
+                                       const AliasVector& untrustedCertificates)
+{
+    m_impl->getCertificateChain(observer, certificate, untrustedCertificates);
+}
+
+void ManagerAsync::createSignature(const ObserverPtr& observer,
+                                   const Alias& privateKeyAlias,
+                                   const Password& password,
+                                   const RawBuffer& message,
+                                   const HashAlgorithm hash,
+                                   const RSAPaddingAlgorithm padding)
+{
+    m_impl->createSignature(observer, privateKeyAlias, password, message, hash, padding);
+}
+
+void ManagerAsync::verifySignature(const ObserverPtr& observer,
+                                   const Alias& publicKeyOrCertAlias,
+                                   const Password& password,
+                                   const RawBuffer& message,
+                                   const RawBuffer& signature,
+                                   const HashAlgorithm hash,
+                                   const RSAPaddingAlgorithm padding)
+{
+    m_impl->verifySignature(observer, publicKeyOrCertAlias, password, message, signature, hash, padding);
+}
+
+void ManagerAsync::ocspCheck(const ObserverPtr& observer,
+                             const CertificateShPtrVector& certificateChainVector)
+{
+    m_impl->ocspCheck(observer, certificateChainVector);
+}
+
+void ManagerAsync::allowAccess(const ObserverPtr& observer,
+                               const std::string& alias,
+                               const std::string& accessor,
+                               AccessRight granted)
+{
+    m_impl->allowAccess(observer, alias, accessor, granted);
+}
+
+void ManagerAsync::denyAccess(const ObserverPtr& observer,
+                              const std::string& alias,
+                              const std::string& accessor)
+{
+    m_impl->denyAccess(observer, alias, accessor);
+}
+
 } // namespace CKM