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