tests/ckm/async-api.cpp

   1 /*
   2  *  Copyright (c) 2000 - 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Contact: Bumjin Im <bj.im@samsung.com>
   5  *
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License
  17  */
  18 /*
  19  * @file       async-api.cpp
  20  * @author     Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
  21  * @version    1.0
  22  */
  23
  24 #include <mutex>
  25 #include <utility>
  26 #include <condition_variable>
  27 #include <cassert>
  28
  29 #include <ckmc/ckmc-type.h>
  30 #include <ckm/ckm-manager-async.h>
  31 #include <ckm/ckm-manager.h>
  32 #include <ckm/ckm-control.h>
  33 #include <ckm/ckm-raw-buffer.h>
  34
  35 #include <fstream>
  36
  37 #include <dpl/test/test_runner.h>
  38 #include <dpl/test/test_runner_child.h>
  39 #include <dpl/log/log.h>
  40
  41 #include <tests_common.h>
  42 #include <ckm-common.h>
  43
  44 using namespace CKM;
  45 using namespace std;
  46
  47 namespace {
  48
  49 const char* TEST_LABEL = "test_label";
  50
  51 class MyObserver: public ManagerAsync::Observer
  52 {
  53 public:
  54     MyObserver() :
  55             m_finished(false), m_error(0)
  56     {
  57     }
  58
  59     void ReceivedError(int error)
  60     {
  61         LogError("Received error: " << error);
  62         m_finished = true;
  63         m_error = error;
  64         m_cv.notify_one();
  65     }
  66
  67     void ReceivedSaveKey() { Succeeded(); }
  68     void ReceivedSaveCertificate() { Succeeded(); }
  69     void ReceivedSaveData() { Succeeded(); }
  70     void ReceivedSavePKCS12() { Succeeded(); }
  71
  72     void ReceivedRemovedAlias() { Succeeded(); }
  73
  74     void ReceivedKey(Key &&) { Succeeded(); }
  75     void ReceivedCertificate(Certificate &&) { Succeeded(); }
  76     void ReceivedData(RawBuffer &&) { Succeeded(); }
  77     void ReceivedPKCS12(PKCS12ShPtr && pkcs) { m_pkcs = pkcs; Succeeded(); }
  78
  79     void ReceivedKeyAliasVector(AliasVector && av) { m_aliases = move(av); Succeeded(); }
  80     void ReceivedCertificateAliasVector(AliasVector && av) { m_aliases = move(av); Succeeded(); }
  81     void ReceivedDataAliasVector(AliasVector && av) { m_aliases = move(av); Succeeded(); }
  82
  83     void ReceivedCreateKeyPairRSA() { Succeeded(); }
  84     void ReceivedCreateKeyPairDSA() { Succeeded(); }
  85     void ReceivedCreateKeyPairECDSA() { Succeeded(); }
  86
  87     void ReceivedGetCertificateChain(CertificateShPtrVector && chain)
  88             { m_certChain = move(chain); Succeeded(); }
  89
  90     void ReceivedCreateSignature(RawBuffer && buffer) { m_signed = move(buffer); Succeeded(); }
  91     void ReceivedVerifySignature() { Succeeded(); }
  92
  93     void ReceivedOCSPCheck(int status) { m_ocspStatus = status; Succeeded(); }
  94
  95     void ReceivedSetPermission() { Succeeded(); }
  96
  97     void WaitForResponse()
  98     {
  99         unique_lock < mutex > lock(m_mutex);
 100
 101         m_cv.wait(lock, [this] {return m_finished;});
 102     }
 103
 104     bool m_finished;
 105     int m_error;
 106     AliasVector m_aliases;
 107     CertificateShPtrVector m_certChain;
 108     PKCS12ShPtr m_pkcs;
 109     RawBuffer m_signed;
 110     int m_ocspStatus;
 111
 112 protected:
 113     void Succeeded()
 114     {
 115         LogDebug("Succeeded");
 116         m_finished = true;
 117         m_cv.notify_one();
 118     }
 119
 120     mutex m_mutex;
 121     condition_variable m_cv;
 122 };
 123
 124 typedef shared_ptr<MyObserver> MyObserverPtr;
 125
 126 const char* TEST_PASS = "test-pass";
 127
 128 enum Type {
 129     RSA,
 130     DSA,
 131     ECDSA
 132 };
 133
 134 struct KeyPair
 135 {
 136     KeyPair(const std::string& prv_pem, const std::string& pub_pem) {
 137         RawBuffer buffer_prv(prv_pem.begin(), prv_pem.end());
 138         prv = Key::create(buffer_prv);
 139         assert(prv);
 140
 141         RawBuffer buffer_pub(pub_pem.begin(), pub_pem.end());
 142         pub = Key::create(buffer_pub);
 143         assert(pub);
 144     }
 145
 146     KeyShPtr prv;
 147     KeyShPtr pub;
 148 };
 149
 150 typedef map<Type, vector<KeyPair> > KeyMap;
 151
 152
 153 KeyMap initializeKeys()
 154 {
 155     KeyMap km;
 156
 157     km[RSA].emplace_back(
 158             "-----BEGIN RSA PRIVATE KEY-----\n"
 159             "MIICXAIBAAKBgQDMP6sKttnQ58BAi27b8X+8KVQtJgpJhhCF0RtWaTVqAhVDG3y4\n"
 160             "x6IuAvXDtPSjLe/2E01fYGVxNComPJOmUOfUD06BCWPYH2+7jOfQIOy/TMlt+W7x\n"
 161             "fou9rqnPRoKRaodoLqH5WK0ahkntWCAjstoKZoG+3Op0tEjy0jpmzeyNiQIDAQAB\n"
 162             "AoGBAJRDX1CuvNx1bkwsKvQDkTqwMYd4hp0qcVICIbsPMhPaoT6OdHHZkHOf+HDx\n"
 163             "KWhOj1LsXgzu95Q+Tp5k+LURI8ayu2RTsz/gYECgPNUsZ7gXl4co1bK+g5kiC+qr\n"
 164             "sgSfkbYpp0OXefnl5x4KaJlZeSpn0UdDqx0kwI1x2E098i1VAkEA5thNY9YZNQdN\n"
 165             "p6aopxOF5OmAjbLkq6wu255rDM5YgeepXXro/lmPociobtv8vPzbWKfoYZJL0Zj4\n"
 166             "Qzj7Qz7s0wJBAOKBbpeG9PuNP1nR1h8kvyuILW8F89JOcIOUeqwokq4eJVqXdFIj\n"
 167             "ct8eSEFmyXNqXD7b9+Tcw6vRIZuddVhNcrMCQAlpaD5ZzE1NLu1W7ilhsmPS4Vrl\n"
 168             "oE0fiAmMO/EZuKITP+R/zmAQZrrB45whe/x4krjan67auByjj/utpxDmz+ECQEg/\n"
 169             "UK80dN/n5dUYgVvdtLyF6zgGhgcGzgyqR5ayOlcfdnq25Htuoy1X02RJDOirfFDw\n"
 170             "iNmPMTqUskuYpd1MltECQBwcy1cpnJWIXwCTQwg3enjkOVw80Tbr3iU9ASjHJTH2\n"
 171             "N6FGHC4BQCm1fL6Bo0/0oSra+Ika3/1Vw1WwijUSiO8=\n"
 172             "-----END RSA PRIVATE KEY-----",
 173
 174             "-----BEGIN PUBLIC KEY-----\n"
 175             "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDMP6sKttnQ58BAi27b8X+8KVQt\n"
 176             "JgpJhhCF0RtWaTVqAhVDG3y4x6IuAvXDtPSjLe/2E01fYGVxNComPJOmUOfUD06B\n"
 177             "CWPYH2+7jOfQIOy/TMlt+W7xfou9rqnPRoKRaodoLqH5WK0ahkntWCAjstoKZoG+\n"
 178             "3Op0tEjy0jpmzeyNiQIDAQAB\n"
 179             "-----END PUBLIC KEY-----"
 180     );
 181     km[DSA].emplace_back(
 182             "-----BEGIN DSA PRIVATE KEY-----\n"
 183             "MIIBuwIBAAKBgQDIsQRYgnU4mm5VrMyykpNNzeHTQAO8E2hJAcOwNPBrdos8amak\n"
 184             "rcJnyBaNh56ZslcuXNEKJuxiDsy4VM9KUR8fHTqTiF5s+4NArzdrdwNQpKWjAqJN\n"
 185             "fgpCdaLZHw9o857flcQ4dyYNnAz1/SNGnv03Dm8EYRNRFNaFNw7zBPjyVwIVANyj\n"
 186             "7ijLfrCbDZDi6ond5Np1Ns0hAoGBAIcS1ceWtw6DAGmYww27r/1lLtqjrq8j0w0a\n"
 187             "F6Ly+pZ/y+WTw9KT18eRKPmVgruVSn3VVVJeN00XaoKvfPSHkTRIE5rro2ZEInhp\n"
 188             "3g0Vak7EXJWe7KKBRXqSMNFkndjKv1nyNKeWSEq9Xql6SPn8J8TfmbyUpPSIglZR\n"
 189             "vJ2DHwHJAoGAPZLRdIhIIJi4UWoyQrCqk1iF3pkBeukXzeZGqNWEjgzLAjMZEVYM\n"
 190             "DLLKippahjxLZSWB7LOoS+XE4fonpBBute/tgF23ToR8fQuiBu+KvtAP/QuCOJ/L\n"
 191             "S0aYYr1/eXmMByYPZ58Vf93KuUgoUAkWmc+mLBn6J2+fygnWcOOSo6sCFC/slPOv\n"
 192             "yAKPlW7WQzgV5jLLNUW7\n"
 193             "-----END DSA PRIVATE KEY-----",
 194
 195             "-----BEGIN DSA PRIVATE KEY-----\n"
 196             "MIIBuwIBAAKBgQDIsQRYgnU4mm5VrMyykpNNzeHTQAO8E2hJAcOwNPBrdos8amak\n"
 197             "rcJnyBaNh56ZslcuXNEKJuxiDsy4VM9KUR8fHTqTiF5s+4NArzdrdwNQpKWjAqJN\n"
 198             "fgpCdaLZHw9o857flcQ4dyYNnAz1/SNGnv03Dm8EYRNRFNaFNw7zBPjyVwIVANyj\n"
 199             "7ijLfrCbDZDi6ond5Np1Ns0hAoGBAIcS1ceWtw6DAGmYww27r/1lLtqjrq8j0w0a\n"
 200             "F6Ly+pZ/y+WTw9KT18eRKPmVgruVSn3VVVJeN00XaoKvfPSHkTRIE5rro2ZEInhp\n"
 201             "3g0Vak7EXJWe7KKBRXqSMNFkndjKv1nyNKeWSEq9Xql6SPn8J8TfmbyUpPSIglZR\n"
 202             "vJ2DHwHJAoGAPZLRdIhIIJi4UWoyQrCqk1iF3pkBeukXzeZGqNWEjgzLAjMZEVYM\n"
 203             "DLLKippahjxLZSWB7LOoS+XE4fonpBBute/tgF23ToR8fQuiBu+KvtAP/QuCOJ/L\n"
 204             "S0aYYr1/eXmMByYPZ58Vf93KuUgoUAkWmc+mLBn6J2+fygnWcOOSo6sCFC/slPOv\n"
 205             "yAKPlW7WQzgV5jLLNUW7\n"
 206             "-----END DSA PRIVATE KEY-----"
 207     );
 208     km[ECDSA].emplace_back(
 209             "-----BEGIN EC PRIVATE KEY-----\n"
 210             "MF8CAQEEGF3rz8OuFpcESrlqCm0G96oovr0XbX+DRKAKBggqhkjOPQMBAaE0AzIA\n"
 211             "BHiZYByQiRNQ91GWNnTfoBbp9G8DP9oJYc/cDZlk4lKUpmbvm//RWf1U7ag3tOVy\n"
 212             "sQ==\n"
 213             "-----END EC PRIVATE KEY-----",
 214
 215             "-----BEGIN PUBLIC KEY-----\n"
 216             "MEkwEwYHKoZIzj0CAQYIKoZIzj0DAQEDMgAEeJlgHJCJE1D3UZY2dN+gFun0bwM/\n"
 217             "2glhz9wNmWTiUpSmZu+b/9FZ/VTtqDe05XKx\n"
 218             "-----END PUBLIC KEY-----"
 219     );
 220     return km;
 221 }
 222
 223 KeyMap keys = initializeKeys();
 224
 225 CertificateShPtr createCert(const std::string& cert) {
 226     RawBuffer buffer_cert(cert.begin(), cert.end());
 227     CertificateShPtr cptr = Certificate::create(buffer_cert, DataFormat::FORM_PEM);
 228     assert(cptr);
 229     return cptr;
 230 }
 231
 232 typedef vector<CertificateShPtr> CertVector;
 233
 234 CertVector initializeCerts()
 235 {
 236     CertVector cv;
 237     cv.emplace_back(createCert(
 238         "-----BEGIN CERTIFICATE-----\n"
 239         "MIIF0TCCBLmgAwIBAgIQaPGTP4aS7Ut/WDNaBzdQrDANBgkqhkiG9w0BAQUFADCB\n"
 240         "ujELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
 241         "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2Ug\n"
 242         "YXQgaHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMr\n"
 243         "VmVyaVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTAeFw0x\n"
 244         "NDAyMjAwMDAwMDBaFw0xNTAyMjAyMzU5NTlaMIHmMRMwEQYLKwYBBAGCNzwCAQMT\n"
 245         "AlBMMR0wGwYDVQQPExRQcml2YXRlIE9yZ2FuaXphdGlvbjETMBEGA1UEBRMKMDAw\n"
 246         "MDAyNTIzNzELMAkGA1UEBhMCUEwxDzANBgNVBBEUBjAwLTk1MDEUMBIGA1UECBML\n"
 247         "bWF6b3dpZWNraWUxETAPBgNVBAcUCFdhcnN6YXdhMRYwFAYDVQQJFA1TZW5hdG9y\n"
 248         "c2thIDE4MRMwEQYDVQQKFAptQmFuayBTLkEuMQwwCgYDVQQLFANESU4xGTAXBgNV\n"
 249         "BAMUEHd3dy5tYmFuay5jb20ucGwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK\n"
 250         "AoIBAQDph6x8V6xUW/+651+qHF+UmorH9uaz2ZrX2bIWiMKIJFmpDDHlxcapKkqE\n"
 251         "BV04is83aiCpqKtc2ZHy2g4Hpj1eSF5BP2+OAlo0YUQZPIeRRdiMjmeAxw/ncBDx\n"
 252         "9rQBuCJ4XTD6cqQox5SI0TASOZ+wyAEjbDRXzL73XqRAFZ1LOpb2ONkolS+RutMB\n"
 253         "vshvCsWPeNe7eGLuOh6DyC6r1vX9xhw3xnjM2mTSvmtimgzSLacNGKqRrsucUgcb\n"
 254         "0+O5C2jZAtAMLyZksL92cxmWbtVzUYzem4chjHu5cRxUlPNzUJWrrczueB7Ip4A8\n"
 255         "aQuFMfNXYc0x+WLWjy//urypMKjhAgMBAAGjggGjMIIBnzAbBgNVHREEFDASghB3\n"
 256         "d3cubWJhbmsuY29tLnBsMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgWgMB0GA1Ud\n"
 257         "JQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjBEBgNVHSAEPTA7MDkGC2CGSAGG+EUB\n"
 258         "BxcGMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8vd3d3LnZlcmlzaWduLmNvbS9jcHMw\n"
 259         "HQYDVR0OBBYEFN37iGaS7mZnENxZ9FGqNLR+QgoMMB8GA1UdIwQYMBaAFPyKULqe\n"
 260         "uSVae1WFT5UAY4/pWGtDMEIGA1UdHwQ7MDkwN6A1oDOGMWh0dHA6Ly9FVlNlY3Vy\n"
 261         "ZS1jcmwudmVyaXNpZ24uY29tL0VWU2VjdXJlMjAwNi5jcmwwfAYIKwYBBQUHAQEE\n"
 262         "cDBuMC0GCCsGAQUFBzABhiFodHRwOi8vRVZTZWN1cmUtb2NzcC52ZXJpc2lnbi5j\n"
 263         "b20wPQYIKwYBBQUHMAKGMWh0dHA6Ly9FVlNlY3VyZS1haWEudmVyaXNpZ24uY29t\n"
 264         "L0VWU2VjdXJlMjAwNi5jZXIwDQYJKoZIhvcNAQEFBQADggEBAD0wO+rooUrIM4qp\n"
 265         "PHhp+hkXK6WMQ2qzGOmbMcZjw0govg5vkzkefPDryIXXbrF8mRagiJNMSfNaWWeh\n"
 266         "Cj41OV24EdUl0OLbFxNzcvub599zRs/apfaRLTfsmlmOgi0/YP305i+3tJ2ll946\n"
 267         "P+qV1wXnXqTqEdIl4Ys3+1HmDCdTB1hoDwAAzqRVUXZ5+iiwPAU7R/LTHfMjV1ke\n"
 268         "8jtNFfrorlZMCfVH/7eEnHJvVjOJt+YFe4aFMzE+DfuYIK7MH+olC2v79kBwbnEQ\n"
 269         "fvHMA9gFwOYLUBBdSfcocp8EKZ+mRlNPGR/3LBrPeaQQ0GZEkxzRK+v/aNTuiYfr\n"
 270         "oFXtrg0=\n"
 271         "-----END CERTIFICATE-----\n"
 272     ));
 273
 274     cv.emplace_back(createCert(
 275         "-----BEGIN CERTIFICATE-----\n"
 276         "MIIF5DCCBMygAwIBAgIQW3dZxheE4V7HJ8AylSkoazANBgkqhkiG9w0BAQUFADCB\n"
 277         "yjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL\n"
 278         "ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJp\n"
 279         "U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxW\n"
 280         "ZXJpU2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0\n"
 281         "aG9yaXR5IC0gRzUwHhcNMDYxMTA4MDAwMDAwWhcNMTYxMTA3MjM1OTU5WjCBujEL\n"
 282         "MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW\n"
 283         "ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2UgYXQg\n"
 284         "aHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykwNjE0MDIGA1UEAxMrVmVy\n"
 285         "aVNpZ24gQ2xhc3MgMyBFeHRlbmRlZCBWYWxpZGF0aW9uIFNTTCBDQTCCASIwDQYJ\n"
 286         "KoZIhvcNAQEBBQADggEPADCCAQoCggEBAJjboFXrnP0XeeOabhQdsVuYI4cWbod2\n"
 287         "nLU4O7WgerQHYwkZ5iqISKnnnbYwWgiXDOyq5BZpcmIjmvt6VCiYxQwtt9citsj5\n"
 288         "OBfH3doxRpqUFI6e7nigtyLUSVSXTeV0W5K87Gws3+fBthsaVWtmCAN/Ra+aM/EQ\n"
 289         "wGyZSpIkMQht3QI+YXZ4eLbtfjeubPOJ4bfh3BXMt1afgKCxBX9ONxX/ty8ejwY4\n"
 290         "P1C3aSijtWZfNhpSSENmUt+ikk/TGGC+4+peGXEFv54cbGhyJW+ze3PJbb0S/5tB\n"
 291         "Ml706H7FC6NMZNFOvCYIZfsZl1h44TO/7Wg+sSdFb8Di7Jdp91zT91ECAwEAAaOC\n"
 292         "AdIwggHOMB0GA1UdDgQWBBT8ilC6nrklWntVhU+VAGOP6VhrQzASBgNVHRMBAf8E\n"
 293         "CDAGAQH/AgEAMD0GA1UdIAQ2MDQwMgYEVR0gADAqMCgGCCsGAQUFBwIBFhxodHRw\n"
 294         "czovL3d3dy52ZXJpc2lnbi5jb20vY3BzMD0GA1UdHwQ2MDQwMqAwoC6GLGh0dHA6\n"
 295         "Ly9FVlNlY3VyZS1jcmwudmVyaXNpZ24uY29tL3BjYTMtZzUuY3JsMA4GA1UdDwEB\n"
 296         "/wQEAwIBBjARBglghkgBhvhCAQEEBAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZ\n"
 297         "MFcwVRYJaW1hZ2UvZ2lmMCEwHzAHBgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7\n"
 298         "GS4wJRYjaHR0cDovL2xvZ28udmVyaXNpZ24uY29tL3ZzbG9nby5naWYwKQYDVR0R\n"
 299         "BCIwIKQeMBwxGjAYBgNVBAMTEUNsYXNzM0NBMjA0OC0xLTQ3MD0GCCsGAQUFBwEB\n"
 300         "BDEwLzAtBggrBgEFBQcwAYYhaHR0cDovL0VWU2VjdXJlLW9jc3AudmVyaXNpZ24u\n"
 301         "Y29tMB8GA1UdIwQYMBaAFH/TZafC3ey78DAJ80M5+gKvMzEzMA0GCSqGSIb3DQEB\n"
 302         "BQUAA4IBAQCWovp/5j3t1CvOtxU/wHIDX4u6FpAl98KD2Md1NGNoElMMU4l7yVYJ\n"
 303         "p8M2RE4O0GJis4b66KGbNGeNUyIXPv2s7mcuQ+JdfzOE8qJwwG6Cl8A0/SXGI3/t\n"
 304         "5rDFV0OEst4t8dD2SB8UcVeyrDHhlyQjyRNddOVG7wl8nuGZMQoIeRuPcZ8XZsg4\n"
 305         "z+6Ml7YGuXNG5NOUweVgtSV1LdlpMezNlsOjdv3odESsErlNv1HoudRETifLriDR\n"
 306         "fip8tmNHnna6l9AW5wtsbfdDbzMLKTB3+p359U64drPNGLT5IO892+bKrZvQTtKH\n"
 307         "qQ2mRHNQ3XBb7a1+Srwi1agm5MKFIA3Z\n"
 308         "-----END CERTIFICATE-----\n"
 309     ));
 310     return cv;
 311 }
 312
 313 CertVector certs = initializeCerts();
 314
 315 const RawBuffer raw_buffer(const char* buffer)
 316 {
 317     return RawBuffer(buffer, buffer + strlen(buffer));
 318 }
 319
 320 const RawBuffer test_buffer = raw_buffer("test_string");
 321
 322 template <typename F, typename... Args>
 323 void test_negative(F&& func, int expected, Args... args)
 324 {
 325     MyObserverPtr obs = make_shared<MyObserver>();
 326     ManagerAsync mgr;
 327
 328     (mgr.*func)(static_pointer_cast < ManagerAsync::Observer > (obs), args...);
 329     obs->WaitForResponse();
 330
 331     RUNNER_ASSERT_MSG(obs->m_finished, "Request is not finished!");
 332     RUNNER_ASSERT_MSG(
 333             obs->m_error == expected,
 334             "Expected " << expected << "/" << ErrorToString(expected) <<
 335             " got: " << obs->m_error << "/" << ErrorToString(obs->m_error));
 336 }
 337
 338 template <typename F, typename... Args>
 339 void test_invalid_param(F&& func, Args... args)
 340 {
 341     test_negative(move(func), CKM_API_ERROR_INPUT_PARAM, args...);
 342 }
 343
 344 template <typename F, typename... Args>
 345 void test_no_observer(F&& func, Args... args)
 346 {
 347     ManagerAsync::ObserverPtr obs;
 348     ManagerAsync mgr;
 349
 350     try {
 351         (mgr.*func)(obs, args...);
 352         RUNNER_ASSERT_MSG(false, "function() should have thrown an exception");
 353     } catch (const invalid_argument& e) {
 354         RUNNER_ASSERT(true);
 355     } catch (...) {
 356         RUNNER_ASSERT_MSG(false, "Unexpected exception");
 357     }
 358 }
 359
 360 template <typename F, typename... Args>
 361 MyObserverPtr test_positive(F&& func, Args... args)
 362 {
 363     MyObserverPtr obs = make_shared<MyObserver>();
 364     ManagerAsync mgr;
 365
 366     (mgr.*func)(static_pointer_cast < ManagerAsync::Observer > (obs), args...);
 367     obs->WaitForResponse();
 368
 369     RUNNER_ASSERT_MSG(obs->m_finished, "Request is not finished!");
 370     RUNNER_ASSERT_MSG(obs->m_error == 0,
 371                          "Request failed " << obs->m_error << "/" << ErrorToString(obs->m_error));
 372     return obs;
 373 }
 374
 375 template <typename F, typename... Args>
 376 void test_check_aliases(F&& func, const AliasVector& expected, Args... args)
 377 {
 378     auto obs = test_positive(move(func), args...);
 379     RUNNER_ASSERT_MSG(obs->m_aliases == expected, "Retrieved aliases differ from expected");
 380 }
 381
 382 template <typename F, typename... Args>
 383 void test_check_cert_chain(F&& func, size_t expected, Args... args)
 384 {
 385     auto obs = test_positive(move(func), args...);
 386     RUNNER_ASSERT_MSG(
 387             obs->m_certChain.size() == expected,
 388             "Expected chain length: " << expected << " got: " << obs->m_certChain.size());
 389 }
 390
 391 typedef void (ManagerAsync::*certChainFn1)(const ManagerAsync::ObserverPtr&,
 392                                            const CertificateShPtr&,
 393                                            const CertificateShPtrVector&);
 394
 395 typedef void (ManagerAsync::*certChainFn2)(const ManagerAsync::ObserverPtr&,
 396                                            const CertificateShPtr&,
 397                                            const AliasVector&);
 398 } // namespace anonymous
 399
 400
 401 RUNNER_TEST_GROUP_INIT(CKM_ASYNC_API);
 402
 403 RUNNER_TEST(TA0000_init)
 404 {
 405     int temp;
 406     ControlShPtr control = Control::create();
 407     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == (temp = control->removeUserData(APP_UID)),
 408                          "Error=" << ErrorToString(temp));
 409 }
 410
 411 // saveKey
 412 RUNNER_CHILD_TEST(TA0010_save_key_invalid_param)
 413 {
 414     switch_to_storage_user(TEST_LABEL);
 415
 416     test_no_observer(&ManagerAsync::saveKey, "alias", keys[RSA][0].prv, Policy());
 417     test_invalid_param(&ManagerAsync::saveKey, "", keys[RSA][0].prv, Policy());
 418     test_invalid_param(&ManagerAsync::saveKey, "alias", KeyShPtr(), Policy());
 419 }
 420
 421 RUNNER_CHILD_TEST(TA0020_save_key_already_exists)
 422 {
 423     switch_to_storage_user(TEST_LABEL);
 424
 425     DBCleanup dbc;
 426     test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy());
 427     test_negative(&ManagerAsync::saveKey,
 428                   CKM_API_ERROR_DB_ALIAS_EXISTS,
 429                   dbc.alias("alias"),
 430                   keys[RSA][0].prv,
 431                   Policy());
 432 }
 433
 434 RUNNER_CHILD_TEST(TA0050_save_key_positive)
 435 {
 436     switch_to_storage_user(TEST_LABEL);
 437
 438     DBCleanup dbc;
 439     test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy());
 440 }
 441
 442
 443 // saveCertificate
 444 RUNNER_CHILD_TEST(TA0110_save_cert_invalid_param)
 445 {
 446     switch_to_storage_user(TEST_LABEL);
 447
 448     CertificateShPtr cert = Certificate::create(test_buffer, DataFormat::FORM_PEM);
 449     test_no_observer(&ManagerAsync::saveCertificate, "", cert, Policy());
 450     test_invalid_param(&ManagerAsync::saveCertificate, "", cert, Policy());
 451     test_invalid_param(&ManagerAsync::saveCertificate, "alias", CertificateShPtr(), Policy());
 452 }
 453
 454 RUNNER_CHILD_TEST(TA0120_save_cert_already_exists)
 455 {
 456     switch_to_storage_user(TEST_LABEL);
 457
 458     DBCleanup dbc;
 459     test_positive(&ManagerAsync::saveCertificate, dbc.alias("alias"), certs[0], Policy());
 460     test_negative(&ManagerAsync::saveCertificate,
 461                   CKM_API_ERROR_DB_ALIAS_EXISTS,
 462                   dbc.alias("alias"),
 463                   certs[0],
 464                   Policy());
 465 }
 466
 467 RUNNER_CHILD_TEST(TA0150_save_cert_positive)
 468 {
 469     switch_to_storage_user(TEST_LABEL);
 470
 471     DBCleanup dbc;
 472     test_positive(&ManagerAsync::saveCertificate, dbc.alias("alias"), certs[0], Policy());
 473 }
 474
 475
 476 // saveData
 477 RUNNER_CHILD_TEST(TA0210_save_data_invalid_param)
 478 {
 479     switch_to_storage_user(TEST_LABEL);
 480
 481     test_no_observer(&ManagerAsync::saveData, "", test_buffer, Policy());
 482     test_invalid_param(&ManagerAsync::saveData, "", test_buffer, Policy());
 483     test_invalid_param(&ManagerAsync::saveData, "alias", RawBuffer(), Policy());
 484 }
 485
 486 RUNNER_CHILD_TEST(TA0220_save_data_already_exists)
 487 {
 488     switch_to_storage_user(TEST_LABEL);
 489
 490     DBCleanup dbc;
 491     test_positive(&ManagerAsync::saveData, dbc.alias("alias"), test_buffer, Policy());
 492     test_negative(&ManagerAsync::saveData,
 493                   CKM_API_ERROR_DB_ALIAS_EXISTS,
 494                   dbc.alias("alias"),
 495                   test_buffer,
 496                   Policy());
 497 }
 498
 499 RUNNER_CHILD_TEST(TA0250_save_data_positive)
 500 {
 501     switch_to_storage_user(TEST_LABEL);
 502
 503     DBCleanup dbc;
 504     test_positive(&ManagerAsync::saveData, dbc.alias("alias"), test_buffer, Policy());
 505 }
 506
 507
 508 // removeKey
 509 RUNNER_CHILD_TEST(TA0310_remove_alias_invalid_param)
 510 {
 511     switch_to_storage_user(TEST_LABEL);
 512
 513     test_no_observer(&ManagerAsync::removeAlias, "alias");
 514     test_invalid_param(&ManagerAsync::removeAlias, "");
 515 }
 516
 517 RUNNER_CHILD_TEST(TA0330_remove_alias_unknown_alias)
 518 {
 519     switch_to_storage_user(TEST_LABEL);
 520
 521     test_negative(&ManagerAsync::removeAlias, CKM_API_ERROR_DB_ALIAS_UNKNOWN, "non-existing-alias");
 522 }
 523
 524 RUNNER_CHILD_TEST(TA0350_remove_key_positive)
 525 {
 526     switch_to_storage_user(TEST_LABEL);
 527
 528     DBCleanup dbc;
 529     test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy());
 530     test_positive(&ManagerAsync::removeAlias, dbc.alias("alias"));
 531 }
 532
 533
 534 RUNNER_CHILD_TEST(TA0450_remove_cert_positive)
 535 {
 536     switch_to_storage_user(TEST_LABEL);
 537
 538     DBCleanup dbc;
 539     test_positive(&ManagerAsync::saveCertificate, dbc.alias("alias"), certs[0], Policy());
 540     test_positive(&ManagerAsync::removeAlias, dbc.alias("alias"));
 541 }
 542
 543
 544 RUNNER_CHILD_TEST(TA0550_remove_data_positive)
 545 {
 546     switch_to_storage_user(TEST_LABEL);
 547
 548     DBCleanup dbc;
 549     test_positive(&ManagerAsync::saveData, dbc.alias("alias"), test_buffer, Policy());
 550     test_positive(&ManagerAsync::removeAlias, dbc.alias("alias"));
 551 }
 552
 553
 554 // getKey
 555 RUNNER_CHILD_TEST(TA0610_get_key_invalid_param)
 556 {
 557     switch_to_storage_user(TEST_LABEL);
 558
 559     test_no_observer(&ManagerAsync::getKey, "alias", "");
 560     test_invalid_param(&ManagerAsync::getKey, "", "");
 561 }
 562
 563 RUNNER_CHILD_TEST(TA0630_get_key_unknown_alias)
 564 {
 565     switch_to_storage_user(TEST_LABEL);
 566
 567     test_negative(&ManagerAsync::getKey, CKM_API_ERROR_DB_ALIAS_UNKNOWN, "non-existing-alias", "");
 568 }
 569
 570 RUNNER_CHILD_TEST(TA0640_get_key_wrong_password)
 571 {
 572     switch_to_storage_user(TEST_LABEL);
 573
 574     DBCleanup dbc;
 575     test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy("password"));
 576     test_negative(&ManagerAsync::getKey,
 577                   CKM_API_ERROR_SERVER_ERROR,
 578                   dbc.alias("alias"),
 579                   "wrong-password");
 580 }
 581
 582 RUNNER_CHILD_TEST(TA0650_get_key_positive)
 583 {
 584     switch_to_storage_user(TEST_LABEL);
 585
 586     DBCleanup dbc;
 587     test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy("password"));
 588     test_positive(&ManagerAsync::getKey, dbc.alias("alias"), "password");
 589 }
 590
 591
 592 // getCertificate
 593 RUNNER_CHILD_TEST(TA0710_get_cert_invalid_param)
 594 {
 595     switch_to_storage_user(TEST_LABEL);
 596
 597     test_no_observer(&ManagerAsync::getCertificate, "alias", "");
 598     test_invalid_param(&ManagerAsync::getCertificate, "", "");
 599 }
 600
 601 RUNNER_CHILD_TEST(TA0730_get_cert_unknown_alias)
 602 {
 603     switch_to_storage_user(TEST_LABEL);
 604
 605     test_negative(&ManagerAsync::getCertificate,
 606                   CKM_API_ERROR_DB_ALIAS_UNKNOWN,
 607                   "non-existing-alias",
 608                   "");
 609 }
 610
 611 RUNNER_CHILD_TEST(TA0740_get_cert_wrong_password)
 612 {
 613     switch_to_storage_user(TEST_LABEL);
 614
 615     DBCleanup dbc;
 616     test_positive(&ManagerAsync::saveCertificate,
 617                   dbc.alias("alias"),
 618                   certs[0],
 619                   Policy("password"));
 620     test_negative(&ManagerAsync::getCertificate,
 621                   CKM_API_ERROR_SERVER_ERROR,
 622                   dbc.alias("alias"),
 623                   "wrong-password");
 624 }
 625
 626 RUNNER_CHILD_TEST(TA0750_get_cert_positive)
 627 {
 628     switch_to_storage_user(TEST_LABEL);
 629
 630     DBCleanup dbc;
 631     test_positive(&ManagerAsync::saveCertificate, dbc.alias("alias"), certs[0], Policy("password"));
 632     test_positive(&ManagerAsync::getCertificate, dbc.alias("alias"), "password");
 633 }
 634
 635
 636 // getData
 637 RUNNER_CHILD_TEST(TA0810_get_data_invalid_param)
 638 {
 639     switch_to_storage_user(TEST_LABEL);
 640
 641     test_no_observer(&ManagerAsync::getData, "alias", "");
 642     test_invalid_param(&ManagerAsync::getData, "", "");
 643 }
 644
 645 RUNNER_CHILD_TEST(TA0830_get_data_unknown_alias)
 646 {
 647     switch_to_storage_user(TEST_LABEL);
 648
 649     test_negative(&ManagerAsync::getData, CKM_API_ERROR_DB_ALIAS_UNKNOWN, "non-existing-alias", "");
 650 }
 651
 652 RUNNER_CHILD_TEST(TA0840_get_data_wrong_password)
 653 {
 654     switch_to_storage_user(TEST_LABEL);
 655
 656     DBCleanup dbc;
 657     test_positive(&ManagerAsync::saveData, dbc.alias("alias"), test_buffer, Policy("password"));
 658     test_negative(&ManagerAsync::getData,
 659                   CKM_API_ERROR_SERVER_ERROR,
 660                   dbc.alias("alias"),
 661                   "wrong-password");
 662 }
 663
 664 RUNNER_CHILD_TEST(TA0850_get_data_positive)
 665 {
 666     switch_to_storage_user(TEST_LABEL);
 667
 668     DBCleanup dbc;
 669     test_positive(&ManagerAsync::saveData, dbc.alias("alias"), test_buffer, Policy("password"));
 670     test_positive(&ManagerAsync::getData, dbc.alias("alias"), "password");
 671 }
 672
 673
 674 // getKeyAliasVector
 675 RUNNER_CHILD_TEST(TA0910_get_key_alias_vector_invalid_param)
 676 {
 677     switch_to_storage_user(TEST_LABEL);
 678
 679     test_no_observer(&ManagerAsync::getKeyAliasVector);
 680 }
 681
 682 RUNNER_CHILD_TEST(TA0950_get_key_alias_vector_positive)
 683 {
 684     switch_to_storage_user(TEST_LABEL);
 685
 686     DBCleanup dbc;
 687     test_positive(&ManagerAsync::saveKey, dbc.alias("alias1"), keys[RSA][0].prv, Policy());
 688     test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias1")) });
 689
 690     test_positive(&ManagerAsync::saveKey, dbc.alias("alias2"), keys[DSA][0].prv, Policy());
 691     test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias1")),
 692                                                            aliasWithLabel(TEST_LABEL, dbc.alias("alias2")) });
 693
 694     test_positive(&ManagerAsync::removeAlias, dbc.alias("alias1"));
 695     test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias2")) });
 696 }
 697
 698
 699 // getCertificateAliasVector
 700 RUNNER_CHILD_TEST(TA1010_get_cert_alias_vector_invalid_param)
 701 {
 702     switch_to_storage_user(TEST_LABEL);
 703
 704     test_no_observer(&ManagerAsync::getCertificateAliasVector);
 705 }
 706
 707 RUNNER_CHILD_TEST(TA1050_get_cert_alias_vector_positive)
 708 {
 709     switch_to_storage_user(TEST_LABEL);
 710
 711     DBCleanup dbc;
 712     test_positive(&ManagerAsync::saveCertificate, dbc.alias("alias1"), certs[0], Policy());
 713     test_check_aliases(&ManagerAsync::getCertificateAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias1")) });
 714
 715     test_positive(&ManagerAsync::saveCertificate, dbc.alias("alias2"), certs[1], Policy());
 716     test_check_aliases(&ManagerAsync::getCertificateAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias1")),
 717                                                                    aliasWithLabel(TEST_LABEL, dbc.alias("alias2")) });
 718
 719     test_positive(&ManagerAsync::removeAlias, dbc.alias("alias1"));
 720     test_check_aliases(&ManagerAsync::getCertificateAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias2")) });
 721 }
 722
 723
 724 // getDataAliasVector
 725 RUNNER_CHILD_TEST(TA1110_get_data_alias_vector_invalid_param)
 726 {
 727     switch_to_storage_user(TEST_LABEL);
 728
 729     test_no_observer(&ManagerAsync::getDataAliasVector);
 730 }
 731
 732 RUNNER_CHILD_TEST(TA1150_get_data_alias_vector_positive)
 733 {
 734     switch_to_storage_user(TEST_LABEL);
 735
 736     DBCleanup dbc;
 737     test_positive(&ManagerAsync::saveData, dbc.alias("alias1"), test_buffer, Policy());
 738     test_check_aliases(&ManagerAsync::getDataAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias1")) });
 739
 740     test_positive(&ManagerAsync::saveData, dbc.alias("alias2"), test_buffer, Policy());
 741     test_check_aliases(&ManagerAsync::getDataAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias1")),
 742                                                             aliasWithLabel(TEST_LABEL, dbc.alias("alias2")) });
 743
 744     test_positive(&ManagerAsync::removeAlias, dbc.alias("alias1"));
 745     test_check_aliases(&ManagerAsync::getDataAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias2")) });
 746 }
 747
 748
 749 // createKeyPairRSA
 750 RUNNER_CHILD_TEST(TA1210_create_key_pair_rsa_invalid_param)
 751 {
 752     switch_to_storage_user(TEST_LABEL);
 753
 754     test_no_observer(&ManagerAsync::createKeyPairRSA,
 755                      1024,
 756                      "alias_prv",
 757                      "alias_pub",
 758                      Policy(),
 759                      Policy());
 760 }
 761
 762 RUNNER_CHILD_TEST(TA1220_create_key_pair_rsa_already_exists)
 763 {
 764     switch_to_storage_user(TEST_LABEL);
 765
 766     DBCleanup dbc;
 767     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[RSA][0].prv, Policy());
 768     test_negative(&ManagerAsync::createKeyPairRSA,
 769                   CKM_API_ERROR_DB_ALIAS_EXISTS,
 770                   1024,
 771                   dbc.alias("alias_prv"),
 772                   dbc.alias("alias_pub"),
 773                   Policy(),
 774                   Policy());
 775 }
 776
 777 RUNNER_CHILD_TEST(TA1250_create_key_pair_rsa_positive)
 778 {
 779     switch_to_storage_user(TEST_LABEL);
 780
 781     DBCleanup dbc;
 782     test_positive(&ManagerAsync::createKeyPairRSA,
 783                   1024,
 784                   dbc.alias("alias_prv"),
 785                   dbc.alias("alias_pub"),
 786                   Policy(),
 787                   Policy());
 788
 789     test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias_prv")),
 790                                                            aliasWithLabel(TEST_LABEL, dbc.alias("alias_pub")) });
 791 }
 792
 793 // createKeyPairDSA
 794 RUNNER_CHILD_TEST(TA1270_create_key_pair_dsa_invalid_param)
 795 {
 796     switch_to_storage_user(TEST_LABEL);
 797
 798     test_no_observer(&ManagerAsync::createKeyPairDSA,
 799                      1024,
 800                      "alias_prv",
 801                      "alias_pub",
 802                      Policy(),
 803                      Policy());
 804 }
 805
 806 RUNNER_CHILD_TEST(TA1280_create_key_pair_dsa_already_exists)
 807 {
 808     switch_to_storage_user(TEST_LABEL);
 809
 810     DBCleanup dbc;
 811     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[DSA][0].prv, Policy());
 812     test_negative(&ManagerAsync::createKeyPairDSA,
 813                   CKM_API_ERROR_DB_ALIAS_EXISTS,
 814                   1024,
 815                   dbc.alias("alias_prv"),
 816                   dbc.alias("alias_pub"),
 817                   Policy(),
 818                   Policy());
 819 }
 820
 821 RUNNER_CHILD_TEST(TA1290_create_key_pair_dsa_positive)
 822 {
 823     switch_to_storage_user(TEST_LABEL);
 824
 825     DBCleanup dbc;
 826     test_positive(&ManagerAsync::createKeyPairDSA,
 827                   1024,
 828                   dbc.alias("alias_prv"),
 829                   dbc.alias("alias_pub"),
 830                   Policy(),
 831                   Policy());
 832
 833     test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias_prv")),
 834                                                            aliasWithLabel(TEST_LABEL, dbc.alias("alias_pub")) });
 835 }
 836
 837 // createKeyPairECDSA
 838 RUNNER_CHILD_TEST(TA1310_create_key_pair_ecdsa_invalid_param)
 839 {
 840     switch_to_storage_user(TEST_LABEL);
 841
 842     test_no_observer(&ManagerAsync::createKeyPairECDSA,
 843                      ElipticCurve::prime192v1,
 844                      "alias_prv",
 845                      "alias_pub",
 846                      Policy(),
 847                      Policy());
 848 }
 849
 850 RUNNER_CHILD_TEST(TA1320_create_key_pair_ecdsa_already_exists)
 851 {
 852     switch_to_storage_user(TEST_LABEL);
 853
 854     DBCleanup dbc;
 855     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[ECDSA][0].prv, Policy());
 856     test_negative(&ManagerAsync::createKeyPairECDSA,
 857                   CKM_API_ERROR_DB_ALIAS_EXISTS,
 858                   ElipticCurve::prime192v1,
 859                   dbc.alias("alias_prv"),
 860                   dbc.alias("alias_pub"),
 861                   Policy(),
 862                   Policy());
 863 }
 864
 865 RUNNER_CHILD_TEST(TA1350_create_key_pair_ecdsa_positive)
 866 {
 867     switch_to_storage_user(TEST_LABEL);
 868
 869     DBCleanup dbc;
 870     test_positive(&ManagerAsync::createKeyPairECDSA,
 871                   ElipticCurve::prime192v1,
 872                   dbc.alias("alias_prv"),
 873                   dbc.alias("alias_pub"),
 874                   Policy(),
 875                   Policy());
 876
 877     test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias_prv")),
 878                                                            aliasWithLabel(TEST_LABEL, dbc.alias("alias_pub")) });
 879 }
 880
 881
 882 // getCertificateChain
 883 RUNNER_CHILD_TEST(TA1410_get_certificate_chain_invalid_param)
 884 {
 885     switch_to_storage_user(TEST_LABEL);
 886
 887     CertificateShPtr cert = certs[0];
 888     CertificateShPtrVector certv = { certs[1] };
 889     test_no_observer<certChainFn1>(&ManagerAsync::getCertificateChain, cert, certv);
 890     test_invalid_param<certChainFn1>(&ManagerAsync::getCertificateChain,
 891                                      CertificateShPtr(),
 892                                      certv);
 893     test_invalid_param<certChainFn1>(&ManagerAsync::getCertificateChain,
 894                                      cert,
 895                                      CertificateShPtrVector());
 896
 897     Alias alias = "alias";
 898     AliasVector aliasv = { alias };
 899     test_no_observer<certChainFn2>(&ManagerAsync::getCertificateChain, cert, aliasv);
 900     test_invalid_param<certChainFn2>(&ManagerAsync::getCertificateChain,
 901                                      CertificateShPtr(),
 902                                      aliasv);
 903     test_invalid_param<certChainFn2>(&ManagerAsync::getCertificateChain, cert, AliasVector());
 904 }
 905
 906 RUNNER_CHILD_TEST(TA1420_get_certificate_chain_negative)
 907 {
 908     switch_to_storage_user(TEST_LABEL);
 909
 910     DBCleanup dbc;
 911     CertificateShPtr cert = certs[0];
 912     CertificateShPtrVector certv = { certs[0] };
 913     test_negative<certChainFn1>(&ManagerAsync::getCertificateChain,
 914                                 CKM_API_ERROR_VERIFICATION_FAILED,
 915                                 cert,
 916                                 certv);
 917     AliasVector aliasv = { dbc.alias("alias") };
 918     test_positive(&ManagerAsync::saveCertificate, aliasv[0], certs[0], Policy());
 919     test_negative<certChainFn2>(&ManagerAsync::getCertificateChain,
 920                                 CKM_API_ERROR_VERIFICATION_FAILED,
 921                                 cert,
 922                                 aliasv);
 923 }
 924
 925 RUNNER_CHILD_TEST(TA1450_get_certificate_chain_positive)
 926 {
 927     switch_to_storage_user(TEST_LABEL);
 928
 929     DBCleanup dbc;
 930     CertificateShPtr cert = certs[0];
 931     CertificateShPtrVector certv = { certs[1] };
 932     test_check_cert_chain<certChainFn1>(&ManagerAsync::getCertificateChain, 3, cert, certv);
 933
 934     AliasVector aliasv = { dbc.alias("alias") };
 935     test_positive(&ManagerAsync::saveCertificate, aliasv[0], certs[1], Policy());
 936     test_check_cert_chain<certChainFn2>(&ManagerAsync::getCertificateChain, 3, cert, aliasv);
 937 }
 938
 939
 940 // createSignature
 941 RUNNER_CHILD_TEST(TA1510_create_signature_invalid_param)
 942 {
 943     switch_to_storage_user(TEST_LABEL);
 944
 945     test_no_observer(&ManagerAsync::createSignature,
 946                      "alias",
 947                      "",
 948                      test_buffer,
 949                      HashAlgorithm::SHA1,
 950                      RSAPaddingAlgorithm::PKCS1);
 951     test_invalid_param(&ManagerAsync::createSignature,
 952                        "",
 953                        "",
 954                        test_buffer,
 955                        HashAlgorithm::SHA1,
 956                        RSAPaddingAlgorithm::PKCS1);
 957     test_invalid_param(&ManagerAsync::createSignature,
 958                        "alias",
 959                        "",
 960                        RawBuffer(),
 961                        HashAlgorithm::SHA1,
 962                        RSAPaddingAlgorithm::PKCS1);
 963 }
 964
 965 RUNNER_CHILD_TEST(TA1520_create_signature_invalid_password)
 966 {
 967     switch_to_storage_user(TEST_LABEL);
 968
 969     DBCleanup dbc;
 970     test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy("password"));
 971     test_negative(&ManagerAsync::createSignature,
 972                   CKM_API_ERROR_INPUT_PARAM,
 973                   dbc.alias("alias"),
 974                   "wrong-password",
 975                   RawBuffer(),
 976                   HashAlgorithm::SHA1,
 977                   RSAPaddingAlgorithm::PKCS1);
 978 }
 979
 980 RUNNER_CHILD_TEST(TA1550_create_signature_positive)
 981 {
 982     switch_to_storage_user(TEST_LABEL);
 983
 984     DBCleanup dbc;
 985     test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy("password"));
 986     test_positive(&ManagerAsync::createSignature,
 987                   dbc.alias("alias"),
 988                   "password",
 989                   test_buffer,
 990                   HashAlgorithm::SHA1,
 991                   RSAPaddingAlgorithm::PKCS1);
 992 }
 993
 994
 995 // verifySignature
 996 RUNNER_CHILD_TEST(TA1610_verify_signature_invalid_param)
 997 {
 998     switch_to_storage_user(TEST_LABEL);
 999
1000     test_no_observer(&ManagerAsync::verifySignature,
1001                      "",
1002                      "",
1003                      RawBuffer(),
1004                      RawBuffer(),
1005                      HashAlgorithm::SHA1,
1006                      RSAPaddingAlgorithm::PKCS1);
1007     test_invalid_param(&ManagerAsync::verifySignature,
1008                        "",
1009                        "",
1010                        test_buffer,
1011                        test_buffer,
1012                        HashAlgorithm::SHA1,
1013                        RSAPaddingAlgorithm::PKCS1);
1014 }
1015
1016 RUNNER_CHILD_TEST(TA1620_verify_signature_invalid_password)
1017 {
1018     switch_to_storage_user(TEST_LABEL);
1019
1020     DBCleanup dbc;
1021     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[RSA][0].prv, Policy("pass1"));
1022     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_pub"), keys[RSA][0].pub, Policy("pass2"));
1023     auto obs = test_positive(&ManagerAsync::createSignature,
1024                              dbc.alias("alias_prv"),
1025                              "pass1",
1026                              test_buffer,
1027                              HashAlgorithm::SHA1,
1028                              RSAPaddingAlgorithm::PKCS1);
1029
1030     test_negative(&ManagerAsync::verifySignature,
1031                   CKM_API_ERROR_SERVER_ERROR,
1032                   dbc.alias("alias_pub"),
1033                   "wrong-password",
1034                   test_buffer,
1035                   obs->m_signed,
1036                   HashAlgorithm::SHA1,
1037                   RSAPaddingAlgorithm::PKCS1);
1038 }
1039
1040 RUNNER_CHILD_TEST(TA1630_verify_signature_invalid_message)
1041 {
1042     switch_to_storage_user(TEST_LABEL);
1043
1044     DBCleanup dbc;
1045     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[RSA][0].prv, Policy(""));
1046     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_pub"), keys[RSA][0].pub, Policy(""));
1047
1048     auto obs = test_positive(&ManagerAsync::createSignature,
1049                              dbc.alias("alias_prv"),
1050                              "",
1051                              test_buffer,
1052                              HashAlgorithm::SHA1,
1053                              RSAPaddingAlgorithm::PKCS1);
1054
1055     test_negative(&ManagerAsync::verifySignature,
1056                   CKM_API_ERROR_VERIFICATION_FAILED,
1057                   dbc.alias("alias_pub"),
1058                   "",
1059                   raw_buffer("invalid-unsigned-mesage"),
1060                   obs->m_signed,
1061                   HashAlgorithm::SHA1,
1062                   RSAPaddingAlgorithm::PKCS1);
1063 }
1064
1065 RUNNER_CHILD_TEST(TA1640_verify_signature_invalid_signature)
1066 {
1067     switch_to_storage_user(TEST_LABEL);
1068
1069     DBCleanup dbc;
1070     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_pub"), keys[RSA][0].pub, Policy(""));
1071
1072     test_negative(&ManagerAsync::verifySignature,
1073                   CKM_API_ERROR_VERIFICATION_FAILED,
1074                   dbc.alias("alias_pub"),
1075                   "",
1076                   test_buffer,
1077                   raw_buffer("invalid-signature"),
1078                   HashAlgorithm::SHA1,
1079                   RSAPaddingAlgorithm::PKCS1);
1080 }
1081
1082 RUNNER_CHILD_TEST(TA1650_verify_signature_wrong_key)
1083 {
1084     switch_to_storage_user(TEST_LABEL);
1085
1086     DBCleanup dbc;
1087     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[RSA][0].prv, Policy(""));
1088     auto obs = test_positive(&ManagerAsync::createSignature,
1089                              dbc.alias("alias_prv"),
1090                              "",
1091                              test_buffer,
1092                              HashAlgorithm::SHA1,
1093                              RSAPaddingAlgorithm::PKCS1);
1094
1095     test_negative(&ManagerAsync::verifySignature,
1096                   CKM_API_ERROR_SERVER_ERROR,
1097                   dbc.alias("alias_prv"),
1098                   "",
1099                   test_buffer,
1100                   obs->m_signed,
1101                   HashAlgorithm::SHA1,
1102                   RSAPaddingAlgorithm::PKCS1);
1103 }
1104
1105 RUNNER_CHILD_TEST(TA1660_verify_signature_positive)
1106 {
1107     switch_to_storage_user(TEST_LABEL);
1108
1109     DBCleanup dbc;
1110     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[RSA][0].prv, Policy("pass1"));
1111     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_pub"), keys[RSA][0].pub, Policy("pass2"));
1112     auto obs = test_positive(&ManagerAsync::createSignature,
1113                              dbc.alias("alias_prv"),
1114                              "pass1",
1115                              test_buffer,
1116                              HashAlgorithm::SHA1,
1117                              RSAPaddingAlgorithm::PKCS1);
1118
1119     test_positive(&ManagerAsync::verifySignature,
1120                   dbc.alias("alias_pub"),
1121                   "pass2",
1122                   test_buffer,
1123                   obs->m_signed,
1124                   HashAlgorithm::SHA1,
1125                   RSAPaddingAlgorithm::PKCS1);
1126 }
1127
1128
1129 // ocspCheck
1130 RUNNER_CHILD_TEST(TA1710_ocsp_check_invalid_param)
1131 {
1132     test_no_observer(&ManagerAsync::ocspCheck, CertificateShPtrVector());
1133     test_invalid_param(&ManagerAsync::ocspCheck, CertificateShPtrVector());
1134 }
1135
1136 RUNNER_CHILD_TEST(TA1720_ocsp_check_negative)
1137 {
1138     switch_to_storage_ocsp_user(TEST_LABEL);
1139
1140     DBCleanup dbc;
1141     CertificateShPtrVector certv = { certs[0], certs[0] };
1142
1143     auto obs = test_positive(&ManagerAsync::ocspCheck, certv);
1144     RUNNER_ASSERT_MSG(obs->m_ocspStatus != CKM_API_OCSP_STATUS_GOOD,
1145                          "Verification should fail. Got: " << obs->m_ocspStatus);
1146 }
1147
1148 RUNNER_CHILD_TEST(TA1750_ocsp_check_positive)
1149 {
1150     RUNNER_IGNORED_MSG("Fixed in next version of ckm!");
1151     switch_to_storage_ocsp_user(TEST_LABEL);
1152
1153     DBCleanup dbc;
1154     CertificateShPtr cert = certs[0];
1155     CertificateShPtrVector certv = { certs[1] };
1156     auto obs = test_positive<certChainFn1>(&ManagerAsync::getCertificateChain, cert, certv);
1157
1158     auto obs2 = test_positive(&ManagerAsync::ocspCheck, obs->m_certChain);
1159     RUNNER_ASSERT_MSG(obs2->m_ocspStatus == CKM_API_OCSP_STATUS_GOOD,
1160                          "Verification failed. Error: " << obs->m_ocspStatus);
1161 }
1162
1163 // setPermission
1164 RUNNER_CHILD_TEST(TA1810_allow_access_invalid_param)
1165 {
1166     switch_to_storage_user(TEST_LABEL);
1167
1168     test_no_observer(&ManagerAsync::setPermission, "alias", "accessor", CKM::Permission::READ | CKM::Permission::REMOVE);
1169     test_invalid_param(&ManagerAsync::setPermission, "", "accessor", CKM::Permission::READ | CKM::Permission::REMOVE);
1170     test_invalid_param(&ManagerAsync::setPermission, "alias", "", CKM::Permission::READ | CKM::Permission::REMOVE);
1171 }
1172
1173 RUNNER_TEST(TA1820_allow_access)
1174 {
1175     DBCleanup dbc;
1176     CharPtr top_label = get_label();
1177     test_positive(&ManagerAsync::saveData, dbc.alias("alias"), test_buffer, Policy());
1178     test_positive(&ManagerAsync::saveData, dbc.alias("alias2"), test_buffer, Policy());
1179     test_positive(&ManagerAsync::saveData, dbc.alias("alias3"), test_buffer, Policy());
1180     test_positive(&ManagerAsync::setPermission,
1181                   dbc.alias("alias2"),
1182                   TEST_LABEL,
1183                   CKM::Permission::READ);
1184     test_positive(&ManagerAsync::setPermission,
1185                   dbc.alias("alias3"),
1186                   TEST_LABEL,
1187                   CKM::Permission::READ | CKM::Permission::REMOVE);
1188
1189     {
1190         ScopedLabel label(TEST_LABEL);
1191
1192         test_negative(&ManagerAsync::getData, CKM_API_ERROR_DB_ALIAS_UNKNOWN, dbc.alias("alias"), "");
1193         test_negative(&ManagerAsync::removeAlias, CKM_API_ERROR_DB_ALIAS_UNKNOWN, dbc.alias("alias"));
1194
1195         // test from allowed label, but without properly addressing alias (coming from default label)
1196         test_negative(&ManagerAsync::getData, CKM_API_ERROR_DB_ALIAS_UNKNOWN, dbc.alias("alias2"), "");
1197
1198         // now test with appropriate addressing
1199         std::string full_alias2_address = aliasWithLabel(top_label.get(), dbc.alias("alias2"));
1200         test_positive(&ManagerAsync::getData, full_alias2_address, "");
1201         test_negative(&ManagerAsync::removeAlias, CKM_API_ERROR_ACCESS_DENIED, full_alias2_address);
1202
1203         std::string full_alias3_address = aliasWithLabel(top_label.get(), dbc.alias("alias3"));
1204         test_positive(&ManagerAsync::getData, full_alias3_address, "");
1205         test_positive(&ManagerAsync::removeAlias, full_alias3_address);
1206     }
1207 }
1208
1209 // denyAccess
1210 RUNNER_CHILD_TEST(TA1910_deny_access_invalid_param)
1211 {
1212     switch_to_storage_user(TEST_LABEL);
1213
1214     test_no_observer(&ManagerAsync::setPermission, "alias", "accessor", CKM::Permission::NONE);
1215     test_invalid_param(&ManagerAsync::setPermission, "", "accessor", CKM::Permission::NONE);
1216     test_invalid_param(&ManagerAsync::setPermission, "alias", "", CKM::Permission::NONE);
1217 }
1218
1219 RUNNER_TEST(TA1920_deny_access)
1220 {
1221     DBCleanup dbc;
1222     CharPtr top_label = get_label();
1223     test_positive(&ManagerAsync::saveData, dbc.alias("alias"), test_buffer, Policy());
1224     test_positive(&ManagerAsync::setPermission,
1225                   dbc.alias("alias"),
1226                   TEST_LABEL,
1227                   CKM::Permission::READ | CKM::Permission::REMOVE);
1228     test_positive(&ManagerAsync::setPermission, dbc.alias("alias"), TEST_LABEL, CKM::Permission::NONE);
1229
1230     {
1231         ScopedLabel label(TEST_LABEL);
1232
1233         std::string full_alias_address = aliasWithLabel(top_label.get(), dbc.alias("alias"));
1234         test_negative(&ManagerAsync::getData, CKM_API_ERROR_DB_ALIAS_UNKNOWN, full_alias_address, "");
1235         test_negative(&ManagerAsync::removeAlias, CKM_API_ERROR_DB_ALIAS_UNKNOWN, full_alias_address);
1236     }
1237 }
1238
1239 namespace
1240 {
1241 CKM::Alias alias_PKCS_exportable = "async-test-PKCS-export";
1242 CKM::Alias alias_PKCS_not_exportable = "async-test-PKCS-no-export";
1243 }
1244
1245 RUNNER_TEST(TA2000_PKCS_add_bundle_with_chain_certs)
1246 {
1247     DBCleanup dbc;
1248     auto manager = CKM::Manager::create();
1249     std::ifstream is("/usr/share/ckm-test/pkcs.p12");
1250     std::istreambuf_iterator<char> begin(is), end;
1251     std::vector<char> buff(begin, end);
1252
1253     CKM::RawBuffer buffer(buff.size());
1254     memcpy(buffer.data(), buff.data(), buff.size());
1255
1256     auto pkcs = CKM::PKCS12::create(buffer, CKM::Password());
1257     RUNNER_ASSERT_MSG_BT(
1258         NULL != pkcs.get(),
1259         "Error in PKCS12::create()");
1260
1261     auto cert = pkcs->getCertificate();
1262     RUNNER_ASSERT_MSG_BT(
1263         NULL != cert.get(),
1264         "Error in PKCS12::getCertificate()");
1265
1266     auto key = pkcs->getKey();
1267     RUNNER_ASSERT_MSG_BT(
1268         NULL != key.get(),
1269         "Error in PKCS12::getKey()");
1270
1271     auto caVector = pkcs->getCaCertificateShPtrVector();
1272     RUNNER_ASSERT_MSG_BT(
1273         2 == caVector.size(),
1274         "Wrong size of vector");
1275
1276     // save to the CKM
1277     int tmp;
1278     CKM::Policy exportable;
1279     CKM::Policy notExportable(CKM::Password(), false);
1280
1281     test_positive(&ManagerAsync::savePKCS12,
1282                   alias_PKCS_exportable,
1283                   pkcs,
1284                   exportable,
1285                   exportable);
1286     test_negative(&ManagerAsync::savePKCS12,
1287                   CKM_API_ERROR_DB_ALIAS_EXISTS,
1288                   alias_PKCS_exportable,
1289                   pkcs,
1290                   exportable,
1291                   exportable);
1292
1293     test_positive(&ManagerAsync::savePKCS12,
1294                   alias_PKCS_not_exportable,
1295                   pkcs,
1296                   notExportable,
1297                   notExportable);
1298     test_negative(&ManagerAsync::savePKCS12,
1299                   CKM_API_ERROR_DB_ALIAS_EXISTS,
1300                   alias_PKCS_not_exportable,
1301                   pkcs,
1302                   notExportable,
1303                   notExportable);
1304 }
1305
1306 RUNNER_TEST(TA2010_PKCS_get)
1307 {
1308     DBCleanup dbc;
1309     int temp;
1310     auto manager = CKM::Manager::create();
1311
1312     // fail - no entry
1313     test_negative(&ManagerAsync::getPKCS12,
1314                   CKM_API_ERROR_DB_ALIAS_UNKNOWN,
1315                   "i-do-not-exist");
1316
1317
1318     // fail - not exportable
1319     test_negative(&ManagerAsync::getPKCS12,
1320                   CKM_API_ERROR_NOT_EXPORTABLE,
1321                   dbc.alias(alias_PKCS_not_exportable.c_str()));
1322
1323     // success - exportable
1324     auto obs = test_positive(&ManagerAsync::getPKCS12,
1325                              dbc.alias(alias_PKCS_exportable.c_str()));
1326
1327     auto cert = obs->m_pkcs->getCertificate();
1328     RUNNER_ASSERT_MSG_BT(
1329         NULL != cert.get(),
1330         "Error in PKCS12::getCertificate()");
1331
1332     auto key = obs->m_pkcs->getKey();
1333     RUNNER_ASSERT_MSG_BT(
1334         NULL != key.get(),
1335         "Error in PKCS12::getKey()");
1336
1337     auto caVector = obs->m_pkcs->getCaCertificateShPtrVector();
1338     RUNNER_ASSERT_MSG_BT(
1339         2 == caVector.size(),
1340         "Wrong size of vector");
1341 }
1342
1343 RUNNER_TEST(TA9999_deinit)
1344 {
1345     int temp;
1346     ControlShPtr control = Control::create();
1347     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == (temp = control->lockUserKey(APP_UID)),
1348                          "Error=" << ErrorToString(temp));
1349     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == (temp = control->removeUserData(APP_UID)),
1350                          "Error=" << ErrorToString(temp));
1351 }