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