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