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