tests/ckm/async-api.cpp

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