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