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
 327     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == (temp = control->removeUserData(0)),
 328                       "Error=" << CKM::ErrorToString(temp));
 329     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == (temp = control->unlockUserKey(0, TEST_PASS)),
 330                       "Error=" << CKM::ErrorToString(temp));
 331
 332     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == (temp = control->removeUserData(APP_UID)),
 333                       "Error=" << ErrorToString(temp));
 334     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == (temp = control->unlockUserKey(APP_UID, TEST_PASS)),
 335                       "Error=" << ErrorToString(temp));
 336 }
 337
 338 // saveKey
 339 RUNNER_CHILD_TEST(TA0010_save_key_invalid_param)
 340 {
 341     switch_to_storage_user(TEST_LABEL);
 342
 343     test_no_observer(&ManagerAsync::saveKey, "alias", keys[RSA][0].prv, Policy());
 344     test_invalid_param(&ManagerAsync::saveKey, "", keys[RSA][0].prv, Policy());
 345     test_invalid_param(&ManagerAsync::saveKey, "alias", KeyShPtr(), Policy());
 346 }
 347
 348 RUNNER_CHILD_TEST(TA0020_save_key_already_exists)
 349 {
 350     switch_to_storage_user(TEST_LABEL);
 351
 352     DBCleanup dbc;
 353     test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy());
 354     test_negative(&ManagerAsync::saveKey,
 355                   CKM_API_ERROR_DB_ALIAS_EXISTS,
 356                   dbc.alias("alias"),
 357                   keys[RSA][0].prv,
 358                   Policy());
 359 }
 360
 361 RUNNER_CHILD_TEST(TA0050_save_key_positive)
 362 {
 363     switch_to_storage_user(TEST_LABEL);
 364
 365     DBCleanup dbc;
 366     test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy());
 367 }
 368
 369
 370 // saveCertificate
 371 RUNNER_CHILD_TEST(TA0110_save_cert_invalid_param)
 372 {
 373     switch_to_storage_user(TEST_LABEL);
 374
 375     CertificateShPtr cert = Certificate::create(test_buffer, DataFormat::FORM_PEM);
 376     test_no_observer(&ManagerAsync::saveCertificate, "", cert, Policy());
 377     test_invalid_param(&ManagerAsync::saveCertificate, "", cert, Policy());
 378     test_invalid_param(&ManagerAsync::saveCertificate, "alias", CertificateShPtr(), Policy());
 379 }
 380
 381 RUNNER_CHILD_TEST(TA0120_save_cert_already_exists)
 382 {
 383     switch_to_storage_user(TEST_LABEL);
 384
 385     DBCleanup dbc;
 386     test_positive(&ManagerAsync::saveCertificate, dbc.alias("alias"), getTestCertificate(MBANK), Policy());
 387     test_negative(&ManagerAsync::saveCertificate,
 388                   CKM_API_ERROR_DB_ALIAS_EXISTS,
 389                   dbc.alias("alias"),
 390                   getTestCertificate(MBANK),
 391                   Policy());
 392 }
 393
 394 RUNNER_CHILD_TEST(TA0150_save_cert_positive)
 395 {
 396     switch_to_storage_user(TEST_LABEL);
 397
 398     DBCleanup dbc;
 399     test_positive(&ManagerAsync::saveCertificate, dbc.alias("alias"), getTestCertificate(MBANK), Policy());
 400 }
 401
 402
 403 // saveData
 404 RUNNER_CHILD_TEST(TA0210_save_data_invalid_param)
 405 {
 406     switch_to_storage_user(TEST_LABEL);
 407
 408     test_no_observer(&ManagerAsync::saveData, "", test_buffer, Policy());
 409     test_invalid_param(&ManagerAsync::saveData, "", test_buffer, Policy());
 410     test_invalid_param(&ManagerAsync::saveData, "alias", RawBuffer(), Policy());
 411 }
 412
 413 RUNNER_CHILD_TEST(TA0220_save_data_already_exists)
 414 {
 415     switch_to_storage_user(TEST_LABEL);
 416
 417     DBCleanup dbc;
 418     test_positive(&ManagerAsync::saveData, dbc.alias("alias"), test_buffer, Policy());
 419     test_negative(&ManagerAsync::saveData,
 420                   CKM_API_ERROR_DB_ALIAS_EXISTS,
 421                   dbc.alias("alias"),
 422                   test_buffer,
 423                   Policy());
 424 }
 425
 426 RUNNER_CHILD_TEST(TA0250_save_data_positive)
 427 {
 428     switch_to_storage_user(TEST_LABEL);
 429
 430     DBCleanup dbc;
 431     test_positive(&ManagerAsync::saveData, dbc.alias("alias"), test_buffer, Policy());
 432 }
 433
 434
 435 // removeKey
 436 RUNNER_CHILD_TEST(TA0310_remove_alias_invalid_param)
 437 {
 438     switch_to_storage_user(TEST_LABEL);
 439
 440     test_no_observer(&ManagerAsync::removeAlias, "alias");
 441     test_invalid_param(&ManagerAsync::removeAlias, "");
 442 }
 443
 444 RUNNER_CHILD_TEST(TA0330_remove_alias_unknown_alias)
 445 {
 446     switch_to_storage_user(TEST_LABEL);
 447
 448     test_negative(&ManagerAsync::removeAlias, CKM_API_ERROR_DB_ALIAS_UNKNOWN, "non-existing-alias");
 449 }
 450
 451 RUNNER_CHILD_TEST(TA0350_remove_key_positive)
 452 {
 453     switch_to_storage_user(TEST_LABEL);
 454
 455     DBCleanup dbc;
 456     test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy());
 457     test_positive(&ManagerAsync::removeAlias, dbc.alias("alias"));
 458 }
 459
 460
 461 RUNNER_CHILD_TEST(TA0450_remove_cert_positive)
 462 {
 463     switch_to_storage_user(TEST_LABEL);
 464
 465     DBCleanup dbc;
 466     test_positive(&ManagerAsync::saveCertificate, dbc.alias("alias"), getTestCertificate(MBANK), Policy());
 467     test_positive(&ManagerAsync::removeAlias, dbc.alias("alias"));
 468 }
 469
 470
 471 RUNNER_CHILD_TEST(TA0550_remove_data_positive)
 472 {
 473     switch_to_storage_user(TEST_LABEL);
 474
 475     DBCleanup dbc;
 476     test_positive(&ManagerAsync::saveData, dbc.alias("alias"), test_buffer, Policy());
 477     test_positive(&ManagerAsync::removeAlias, dbc.alias("alias"));
 478 }
 479
 480
 481 // getKey
 482 RUNNER_CHILD_TEST(TA0610_get_key_invalid_param)
 483 {
 484     switch_to_storage_user(TEST_LABEL);
 485
 486     test_no_observer(&ManagerAsync::getKey, "alias", "");
 487     test_invalid_param(&ManagerAsync::getKey, "", "");
 488 }
 489
 490 RUNNER_CHILD_TEST(TA0630_get_key_unknown_alias)
 491 {
 492     switch_to_storage_user(TEST_LABEL);
 493
 494     test_negative(&ManagerAsync::getKey, CKM_API_ERROR_DB_ALIAS_UNKNOWN, "non-existing-alias", "");
 495 }
 496
 497 RUNNER_CHILD_TEST(TA0640_get_key_wrong_password)
 498 {
 499     switch_to_storage_user(TEST_LABEL);
 500
 501     DBCleanup dbc;
 502     test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy("password"));
 503     test_negative(&ManagerAsync::getKey,
 504                   CKM_API_ERROR_AUTHENTICATION_FAILED,
 505                   dbc.alias("alias"),
 506                   "wrong-password");
 507 }
 508
 509 RUNNER_CHILD_TEST(TA0650_get_key_positive)
 510 {
 511     switch_to_storage_user(TEST_LABEL);
 512
 513     DBCleanup dbc;
 514     test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy("password"));
 515     test_positive(&ManagerAsync::getKey, dbc.alias("alias"), "password");
 516 }
 517
 518
 519 // getCertificate
 520 RUNNER_CHILD_TEST(TA0710_get_cert_invalid_param)
 521 {
 522     switch_to_storage_user(TEST_LABEL);
 523
 524     test_no_observer(&ManagerAsync::getCertificate, "alias", "");
 525     test_invalid_param(&ManagerAsync::getCertificate, "", "");
 526 }
 527
 528 RUNNER_CHILD_TEST(TA0730_get_cert_unknown_alias)
 529 {
 530     switch_to_storage_user(TEST_LABEL);
 531
 532     test_negative(&ManagerAsync::getCertificate,
 533                   CKM_API_ERROR_DB_ALIAS_UNKNOWN,
 534                   "non-existing-alias",
 535                   "");
 536 }
 537
 538 RUNNER_CHILD_TEST(TA0740_get_cert_wrong_password)
 539 {
 540     switch_to_storage_user(TEST_LABEL);
 541
 542     DBCleanup dbc;
 543     test_positive(&ManagerAsync::saveCertificate,
 544                   dbc.alias("alias"),
 545                   getTestCertificate(MBANK),
 546                   Policy("password"));
 547     test_negative(&ManagerAsync::getCertificate,
 548                   CKM_API_ERROR_AUTHENTICATION_FAILED,
 549                   dbc.alias("alias"),
 550                   "wrong-password");
 551 }
 552
 553 RUNNER_CHILD_TEST(TA0750_get_cert_positive)
 554 {
 555     switch_to_storage_user(TEST_LABEL);
 556
 557     DBCleanup dbc;
 558     test_positive(&ManagerAsync::saveCertificate, dbc.alias("alias"), getTestCertificate(MBANK), Policy("password"));
 559     test_positive(&ManagerAsync::getCertificate, dbc.alias("alias"), "password");
 560 }
 561
 562
 563 // getData
 564 RUNNER_CHILD_TEST(TA0810_get_data_invalid_param)
 565 {
 566     switch_to_storage_user(TEST_LABEL);
 567
 568     test_no_observer(&ManagerAsync::getData, "alias", "");
 569     test_invalid_param(&ManagerAsync::getData, "", "");
 570 }
 571
 572 RUNNER_CHILD_TEST(TA0830_get_data_unknown_alias)
 573 {
 574     switch_to_storage_user(TEST_LABEL);
 575
 576     test_negative(&ManagerAsync::getData, CKM_API_ERROR_DB_ALIAS_UNKNOWN, "non-existing-alias", "");
 577 }
 578
 579 RUNNER_CHILD_TEST(TA0840_get_data_wrong_password)
 580 {
 581     switch_to_storage_user(TEST_LABEL);
 582
 583     DBCleanup dbc;
 584     test_positive(&ManagerAsync::saveData, dbc.alias("alias"), test_buffer, Policy("password"));
 585     test_negative(&ManagerAsync::getData,
 586                   CKM_API_ERROR_AUTHENTICATION_FAILED,
 587                   dbc.alias("alias"),
 588                   "wrong-password");
 589 }
 590
 591 RUNNER_CHILD_TEST(TA0850_get_data_positive)
 592 {
 593     switch_to_storage_user(TEST_LABEL);
 594
 595     DBCleanup dbc;
 596     test_positive(&ManagerAsync::saveData, dbc.alias("alias"), test_buffer, Policy("password"));
 597     test_positive(&ManagerAsync::getData, dbc.alias("alias"), "password");
 598 }
 599
 600
 601 // getKeyAliasVector
 602 RUNNER_CHILD_TEST(TA0910_get_key_alias_vector_invalid_param)
 603 {
 604     switch_to_storage_user(TEST_LABEL);
 605
 606     test_no_observer(&ManagerAsync::getKeyAliasVector);
 607 }
 608
 609 RUNNER_CHILD_TEST(TA0950_get_key_alias_vector_positive)
 610 {
 611     switch_to_storage_user(TEST_LABEL);
 612
 613     DBCleanup dbc;
 614     test_positive(&ManagerAsync::saveKey, dbc.alias("alias1"), keys[RSA][0].prv, Policy());
 615     test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias1")) });
 616
 617     test_positive(&ManagerAsync::saveKey, dbc.alias("alias2"), keys[DSA][0].prv, Policy());
 618     test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias1")),
 619                                                            aliasWithLabel(TEST_LABEL, dbc.alias("alias2")) });
 620
 621     test_positive(&ManagerAsync::removeAlias, dbc.alias("alias1"));
 622     test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias2")) });
 623 }
 624
 625
 626 // getCertificateAliasVector
 627 RUNNER_CHILD_TEST(TA1010_get_cert_alias_vector_invalid_param)
 628 {
 629     switch_to_storage_user(TEST_LABEL);
 630
 631     test_no_observer(&ManagerAsync::getCertificateAliasVector);
 632 }
 633
 634 RUNNER_CHILD_TEST(TA1050_get_cert_alias_vector_positive)
 635 {
 636     switch_to_storage_user(TEST_LABEL);
 637
 638     DBCleanup dbc;
 639     test_positive(&ManagerAsync::saveCertificate, dbc.alias("alias1"), getTestCertificate(MBANK), Policy());
 640     test_check_aliases(&ManagerAsync::getCertificateAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias1")) });
 641
 642     test_positive(&ManagerAsync::saveCertificate, dbc.alias("alias2"), getTestCertificate(SYMANTEC), Policy());
 643     test_check_aliases(&ManagerAsync::getCertificateAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias1")),
 644                                                                    aliasWithLabel(TEST_LABEL, dbc.alias("alias2")) });
 645
 646     test_positive(&ManagerAsync::removeAlias, dbc.alias("alias1"));
 647     test_check_aliases(&ManagerAsync::getCertificateAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias2")) });
 648 }
 649
 650
 651 // getDataAliasVector
 652 RUNNER_CHILD_TEST(TA1110_get_data_alias_vector_invalid_param)
 653 {
 654     switch_to_storage_user(TEST_LABEL);
 655
 656     test_no_observer(&ManagerAsync::getDataAliasVector);
 657 }
 658
 659 RUNNER_CHILD_TEST(TA1150_get_data_alias_vector_positive)
 660 {
 661     switch_to_storage_user(TEST_LABEL);
 662
 663     DBCleanup dbc;
 664     test_positive(&ManagerAsync::saveData, dbc.alias("alias1"), test_buffer, Policy());
 665     test_check_aliases(&ManagerAsync::getDataAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias1")) });
 666
 667     test_positive(&ManagerAsync::saveData, dbc.alias("alias2"), test_buffer, Policy());
 668     test_check_aliases(&ManagerAsync::getDataAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias1")),
 669                                                             aliasWithLabel(TEST_LABEL, dbc.alias("alias2")) });
 670
 671     test_positive(&ManagerAsync::removeAlias, dbc.alias("alias1"));
 672     test_check_aliases(&ManagerAsync::getDataAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias2")) });
 673 }
 674
 675
 676 // createKeyPairRSA
 677 RUNNER_CHILD_TEST(TA1210_create_key_pair_rsa_invalid_param)
 678 {
 679     switch_to_storage_user(TEST_LABEL);
 680
 681     test_no_observer(&ManagerAsync::createKeyPairRSA,
 682                      1024,
 683                      "alias_prv",
 684                      "alias_pub",
 685                      Policy(),
 686                      Policy());
 687 }
 688
 689 RUNNER_CHILD_TEST(TA1220_create_key_pair_rsa_already_exists)
 690 {
 691     switch_to_storage_user(TEST_LABEL);
 692
 693     DBCleanup dbc;
 694     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[RSA][0].prv, Policy());
 695     test_negative(&ManagerAsync::createKeyPairRSA,
 696                   CKM_API_ERROR_DB_ALIAS_EXISTS,
 697                   1024,
 698                   dbc.alias("alias_prv"),
 699                   dbc.alias("alias_pub"),
 700                   Policy(),
 701                   Policy());
 702 }
 703
 704 RUNNER_CHILD_TEST(TA1250_create_key_pair_rsa_positive)
 705 {
 706     switch_to_storage_user(TEST_LABEL);
 707
 708     DBCleanup dbc;
 709     test_positive(&ManagerAsync::createKeyPairRSA,
 710                   1024,
 711                   dbc.alias("alias_prv"),
 712                   dbc.alias("alias_pub"),
 713                   Policy(),
 714                   Policy());
 715
 716     test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias_prv")),
 717                                                            aliasWithLabel(TEST_LABEL, dbc.alias("alias_pub")) });
 718 }
 719
 720 // createKeyPairDSA
 721 RUNNER_CHILD_TEST(TA1270_create_key_pair_dsa_invalid_param)
 722 {
 723     switch_to_storage_user(TEST_LABEL);
 724
 725     test_no_observer(&ManagerAsync::createKeyPairDSA,
 726                      1024,
 727                      "alias_prv",
 728                      "alias_pub",
 729                      Policy(),
 730                      Policy());
 731 }
 732
 733 RUNNER_CHILD_TEST(TA1280_create_key_pair_dsa_already_exists)
 734 {
 735     switch_to_storage_user(TEST_LABEL);
 736
 737     DBCleanup dbc;
 738     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[DSA][0].prv, Policy());
 739     test_negative(&ManagerAsync::createKeyPairDSA,
 740                   CKM_API_ERROR_DB_ALIAS_EXISTS,
 741                   1024,
 742                   dbc.alias("alias_prv"),
 743                   dbc.alias("alias_pub"),
 744                   Policy(),
 745                   Policy());
 746 }
 747
 748 RUNNER_CHILD_TEST(TA1290_create_key_pair_dsa_positive)
 749 {
 750     switch_to_storage_user(TEST_LABEL);
 751
 752     DBCleanup dbc;
 753     test_positive(&ManagerAsync::createKeyPairDSA,
 754                   1024,
 755                   dbc.alias("alias_prv"),
 756                   dbc.alias("alias_pub"),
 757                   Policy(),
 758                   Policy());
 759
 760     test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias_prv")),
 761                                                            aliasWithLabel(TEST_LABEL, dbc.alias("alias_pub")) });
 762 }
 763
 764 // createKeyPairECDSA
 765 RUNNER_CHILD_TEST(TA1310_create_key_pair_ecdsa_invalid_param)
 766 {
 767     switch_to_storage_user(TEST_LABEL);
 768
 769     test_no_observer(&ManagerAsync::createKeyPairECDSA,
 770                      ElipticCurve::prime192v1,
 771                      "alias_prv",
 772                      "alias_pub",
 773                      Policy(),
 774                      Policy());
 775 }
 776
 777 RUNNER_CHILD_TEST(TA1320_create_key_pair_ecdsa_already_exists)
 778 {
 779     switch_to_storage_user(TEST_LABEL);
 780
 781     DBCleanup dbc;
 782     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[ECDSA][0].prv, Policy());
 783     test_negative(&ManagerAsync::createKeyPairECDSA,
 784                   CKM_API_ERROR_DB_ALIAS_EXISTS,
 785                   ElipticCurve::prime192v1,
 786                   dbc.alias("alias_prv"),
 787                   dbc.alias("alias_pub"),
 788                   Policy(),
 789                   Policy());
 790 }
 791
 792 RUNNER_CHILD_TEST(TA1350_create_key_pair_ecdsa_positive)
 793 {
 794     switch_to_storage_user(TEST_LABEL);
 795
 796     DBCleanup dbc;
 797     test_positive(&ManagerAsync::createKeyPairECDSA,
 798                   ElipticCurve::prime192v1,
 799                   dbc.alias("alias_prv"),
 800                   dbc.alias("alias_pub"),
 801                   Policy(),
 802                   Policy());
 803
 804     test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias_prv")),
 805                                                            aliasWithLabel(TEST_LABEL, dbc.alias("alias_pub")) });
 806 }
 807
 808
 809 // getCertificateChain
 810 RUNNER_CHILD_TEST(TA1410_get_certificate_chain_invalid_param)
 811 {
 812     switch_to_storage_user(TEST_LABEL);
 813
 814     CertificateShPtr cert = getTestCertificate(MBANK);
 815     CertificateShPtrVector certv = { getTestCertificate(SYMANTEC) };
 816     test_no_observer<certChainFn1>(&ManagerAsync::getCertificateChain,
 817                                    cert,
 818                                    certv,
 819                                    EMPTY_CERT_VECTOR,
 820                                    true);
 821     test_invalid_param<certChainFn1>(&ManagerAsync::getCertificateChain,
 822                                      CertificateShPtr(),
 823                                      certv,
 824                                      EMPTY_CERT_VECTOR,
 825                                      true);
 826
 827     Alias alias = "alias";
 828     AliasVector aliasv = { alias };
 829     test_no_observer<certChainFn2>(&ManagerAsync::getCertificateChain,
 830                                    cert,
 831                                    aliasv,
 832                                    EMPTY_ALIAS_VECTOR,
 833                                    true);
 834     test_invalid_param<certChainFn2>(&ManagerAsync::getCertificateChain,
 835                                      CertificateShPtr(),
 836                                      aliasv,
 837                                      EMPTY_ALIAS_VECTOR,
 838                                      true);
 839 }
 840
 841 RUNNER_CHILD_TEST(TA1420_get_certificate_chain_negative)
 842 {
 843     switch_to_storage_user(TEST_LABEL);
 844
 845     DBCleanup dbc;
 846     CertificateShPtr cert = getTestCertificate(MBANK);
 847     CertificateShPtrVector certv = { getTestCertificate(MBANK) };
 848     test_negative<certChainFn1>(&ManagerAsync::getCertificateChain,
 849                                 CKM_API_ERROR_VERIFICATION_FAILED,
 850                                 cert,
 851                                 EMPTY_CERT_VECTOR,
 852                                 EMPTY_CERT_VECTOR,
 853                                 true);
 854     test_negative<certChainFn1>(&ManagerAsync::getCertificateChain,
 855                                 CKM_API_ERROR_VERIFICATION_FAILED,
 856                                 cert,
 857                                 certv,
 858                                 EMPTY_CERT_VECTOR,
 859                                 true);
 860     AliasVector aliasv = { dbc.alias("alias") };
 861     test_positive(&ManagerAsync::saveCertificate, aliasv[0], getTestCertificate(MBANK), Policy());
 862     test_negative<certChainFn2>(&ManagerAsync::getCertificateChain,
 863                                 CKM_API_ERROR_VERIFICATION_FAILED,
 864                                 cert,
 865                                 EMPTY_ALIAS_VECTOR,
 866                                 EMPTY_ALIAS_VECTOR,
 867                                 true);
 868     test_negative<certChainFn2>(&ManagerAsync::getCertificateChain,
 869                                 CKM_API_ERROR_VERIFICATION_FAILED,
 870                                 cert,
 871                                 aliasv,
 872                                 EMPTY_ALIAS_VECTOR,
 873                                 true);
 874 }
 875
 876 RUNNER_CHILD_TEST(TA1450_get_certificate_chain_positive)
 877 {
 878     switch_to_storage_user(TEST_LABEL);
 879
 880     DBCleanup dbc;
 881     CertificateShPtr cert = getTestCertificate(MBANK);
 882     CertificateShPtrVector certv = { getTestCertificate(SYMANTEC) };
 883     test_check_cert_chain<certChainFn1>(&ManagerAsync::getCertificateChain,
 884                                         3,
 885                                         cert,
 886                                         certv,
 887                                         EMPTY_CERT_VECTOR,
 888                                         true);
 889
 890     AliasVector aliasv = { dbc.alias("alias") };
 891     test_positive(&ManagerAsync::saveCertificate, aliasv[0], getTestCertificate(SYMANTEC), Policy());
 892     test_check_cert_chain<certChainFn2>(&ManagerAsync::getCertificateChain,
 893                                         3,
 894                                         cert,
 895                                         aliasv,
 896                                         EMPTY_ALIAS_VECTOR,
 897                                         true);
 898 }
 899
 900
 901 // createSignature
 902 RUNNER_CHILD_TEST(TA1510_create_signature_invalid_param)
 903 {
 904     switch_to_storage_user(TEST_LABEL);
 905
 906     test_no_observer(&ManagerAsync::createSignature,
 907                      "alias",
 908                      "",
 909                      test_buffer,
 910                      HashAlgorithm::SHA1,
 911                      RSAPaddingAlgorithm::PKCS1);
 912     test_invalid_param(&ManagerAsync::createSignature,
 913                        "",
 914                        "",
 915                        test_buffer,
 916                        HashAlgorithm::SHA1,
 917                        RSAPaddingAlgorithm::PKCS1);
 918     test_invalid_param(&ManagerAsync::createSignature,
 919                        "alias",
 920                        "",
 921                        RawBuffer(),
 922                        HashAlgorithm::SHA1,
 923                        RSAPaddingAlgorithm::PKCS1);
 924 }
 925
 926 RUNNER_CHILD_TEST(TA1520_create_signature_invalid_password)
 927 {
 928     switch_to_storage_user(TEST_LABEL);
 929
 930     DBCleanup dbc;
 931     test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy("password"));
 932     test_negative(&ManagerAsync::createSignature,
 933                   CKM_API_ERROR_INPUT_PARAM,
 934                   dbc.alias("alias"),
 935                   "wrong-password",
 936                   RawBuffer(),
 937                   HashAlgorithm::SHA1,
 938                   RSAPaddingAlgorithm::PKCS1);
 939 }
 940
 941 RUNNER_CHILD_TEST(TA1550_create_signature_positive)
 942 {
 943     switch_to_storage_user(TEST_LABEL);
 944
 945     DBCleanup dbc;
 946     test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy("password"));
 947     test_positive(&ManagerAsync::createSignature,
 948                   dbc.alias("alias"),
 949                   "password",
 950                   test_buffer,
 951                   HashAlgorithm::SHA1,
 952                   RSAPaddingAlgorithm::PKCS1);
 953 }
 954
 955
 956 // verifySignature
 957 RUNNER_CHILD_TEST(TA1610_verify_signature_invalid_param)
 958 {
 959     switch_to_storage_user(TEST_LABEL);
 960
 961     test_no_observer(&ManagerAsync::verifySignature,
 962                      "",
 963                      "",
 964                      RawBuffer(),
 965                      RawBuffer(),
 966                      HashAlgorithm::SHA1,
 967                      RSAPaddingAlgorithm::PKCS1);
 968     test_invalid_param(&ManagerAsync::verifySignature,
 969                        "",
 970                        "",
 971                        test_buffer,
 972                        test_buffer,
 973                        HashAlgorithm::SHA1,
 974                        RSAPaddingAlgorithm::PKCS1);
 975 }
 976
 977 RUNNER_CHILD_TEST(TA1620_verify_signature_invalid_password)
 978 {
 979     switch_to_storage_user(TEST_LABEL);
 980
 981     DBCleanup dbc;
 982     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[RSA][0].prv, Policy("pass1"));
 983     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_pub"), keys[RSA][0].pub, Policy("pass2"));
 984     auto obs = test_positive(&ManagerAsync::createSignature,
 985                              dbc.alias("alias_prv"),
 986                              "pass1",
 987                              test_buffer,
 988                              HashAlgorithm::SHA1,
 989                              RSAPaddingAlgorithm::PKCS1);
 990
 991     test_negative(&ManagerAsync::verifySignature,
 992                   CKM_API_ERROR_AUTHENTICATION_FAILED,
 993                   dbc.alias("alias_pub"),
 994                   "wrong-password",
 995                   test_buffer,
 996                   obs->m_signed,
 997                   HashAlgorithm::SHA1,
 998                   RSAPaddingAlgorithm::PKCS1);
 999 }
1000
1001 RUNNER_CHILD_TEST(TA1630_verify_signature_invalid_message)
1002 {
1003     switch_to_storage_user(TEST_LABEL);
1004
1005     DBCleanup dbc;
1006     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[RSA][0].prv, Policy(""));
1007     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_pub"), keys[RSA][0].pub, Policy(""));
1008
1009     auto obs = test_positive(&ManagerAsync::createSignature,
1010                              dbc.alias("alias_prv"),
1011                              "",
1012                              test_buffer,
1013                              HashAlgorithm::SHA1,
1014                              RSAPaddingAlgorithm::PKCS1);
1015
1016     test_negative(&ManagerAsync::verifySignature,
1017                   CKM_API_ERROR_VERIFICATION_FAILED,
1018                   dbc.alias("alias_pub"),
1019                   "",
1020                   raw_buffer("invalid-unsigned-mesage"),
1021                   obs->m_signed,
1022                   HashAlgorithm::SHA1,
1023                   RSAPaddingAlgorithm::PKCS1);
1024 }
1025
1026 RUNNER_CHILD_TEST(TA1640_verify_signature_invalid_signature)
1027 {
1028     switch_to_storage_user(TEST_LABEL);
1029
1030     DBCleanup dbc;
1031     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_pub"), keys[RSA][0].pub, Policy(""));
1032
1033     test_negative(&ManagerAsync::verifySignature,
1034                   CKM_API_ERROR_VERIFICATION_FAILED,
1035                   dbc.alias("alias_pub"),
1036                   "",
1037                   test_buffer,
1038                   raw_buffer("invalid-signature"),
1039                   HashAlgorithm::SHA1,
1040                   RSAPaddingAlgorithm::PKCS1);
1041 }
1042
1043 RUNNER_CHILD_TEST(TA1650_verify_signature_wrong_key)
1044 {
1045     switch_to_storage_user(TEST_LABEL);
1046
1047     DBCleanup dbc;
1048     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[RSA][0].prv, Policy(""));
1049     auto obs = test_positive(&ManagerAsync::createSignature,
1050                              dbc.alias("alias_prv"),
1051                              "",
1052                              test_buffer,
1053                              HashAlgorithm::SHA1,
1054                              RSAPaddingAlgorithm::PKCS1);
1055
1056     test_negative(&ManagerAsync::verifySignature,
1057                   CKM_API_ERROR_SERVER_ERROR,
1058                   dbc.alias("alias_prv"),
1059                   "",
1060                   test_buffer,
1061                   obs->m_signed,
1062                   HashAlgorithm::SHA1,
1063                   RSAPaddingAlgorithm::PKCS1);
1064 }
1065
1066 RUNNER_CHILD_TEST(TA1660_verify_signature_positive)
1067 {
1068     switch_to_storage_user(TEST_LABEL);
1069
1070     DBCleanup dbc;
1071     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[RSA][0].prv, Policy("pass1"));
1072     test_positive(&ManagerAsync::saveKey, dbc.alias("alias_pub"), keys[RSA][0].pub, Policy("pass2"));
1073     auto obs = test_positive(&ManagerAsync::createSignature,
1074                              dbc.alias("alias_prv"),
1075                              "pass1",
1076                              test_buffer,
1077                              HashAlgorithm::SHA1,
1078                              RSAPaddingAlgorithm::PKCS1);
1079
1080     test_positive(&ManagerAsync::verifySignature,
1081                   dbc.alias("alias_pub"),
1082                   "pass2",
1083                   test_buffer,
1084                   obs->m_signed,
1085                   HashAlgorithm::SHA1,
1086                   RSAPaddingAlgorithm::PKCS1);
1087 }
1088
1089
1090 // ocspCheck
1091 RUNNER_CHILD_TEST(TA1710_ocsp_check_invalid_param)
1092 {
1093     test_no_observer(&ManagerAsync::ocspCheck, EMPTY_CERT_VECTOR);
1094     test_invalid_param(&ManagerAsync::ocspCheck, EMPTY_CERT_VECTOR);
1095 }
1096
1097 RUNNER_CHILD_TEST(TA1720_ocsp_check_negative)
1098 {
1099     switch_to_storage_ocsp_user(TEST_LABEL);
1100
1101     DBCleanup dbc;
1102     CertificateShPtrVector certv = { getTestCertificate(MBANK), getTestCertificate(MBANK) };
1103
1104     auto obs = test_positive(&ManagerAsync::ocspCheck, certv);
1105     RUNNER_ASSERT_MSG(obs->m_ocspStatus != CKM_API_OCSP_STATUS_GOOD,
1106                          "Verification should fail. Got: " << obs->m_ocspStatus);
1107 }
1108
1109 RUNNER_CHILD_TEST(TA1750_ocsp_check_positive)
1110 {
1111     switch_to_storage_ocsp_user(TEST_LABEL);
1112
1113     DBCleanup dbc;
1114     CertificateShPtr cert = getTestCertificate(MBANK);
1115     CertificateShPtrVector certv = { getTestCertificate(SYMANTEC) };
1116     auto obs = test_positive<certChainFn1>(&ManagerAsync::getCertificateChain,
1117                                            cert,
1118                                            certv,
1119                                            EMPTY_CERT_VECTOR,
1120                                            true);
1121
1122     auto obs2 = test_positive(&ManagerAsync::ocspCheck, obs->m_certChain);
1123     RUNNER_ASSERT_MSG(obs2->m_ocspStatus == CKM_API_OCSP_STATUS_GOOD,
1124                          "Verification failed. Error: " << obs->m_ocspStatus);
1125 }
1126
1127 // setPermission
1128 RUNNER_CHILD_TEST(TA1810_allow_access_invalid_param)
1129 {
1130     switch_to_storage_user(TEST_LABEL);
1131
1132     test_no_observer(&ManagerAsync::setPermission, "alias", "accessor", CKM::Permission::READ | CKM::Permission::REMOVE);
1133     test_invalid_param(&ManagerAsync::setPermission, "", "accessor", CKM::Permission::READ | CKM::Permission::REMOVE);
1134     test_invalid_param(&ManagerAsync::setPermission, "alias", "", CKM::Permission::READ | CKM::Permission::REMOVE);
1135 }
1136
1137 RUNNER_TEST(TA1820_allow_access)
1138 {
1139     DBCleanup dbc;
1140     CharPtr top_label = get_label();
1141     test_positive(&ManagerAsync::saveData, dbc.alias("alias"), test_buffer, Policy());
1142     test_positive(&ManagerAsync::saveData, dbc.alias("alias2"), test_buffer, Policy());
1143     test_positive(&ManagerAsync::saveData, dbc.alias("alias3"), test_buffer, Policy());
1144     test_positive(&ManagerAsync::setPermission,
1145                   dbc.alias("alias2"),
1146                   TEST_LABEL,
1147                   CKM::Permission::READ);
1148     test_positive(&ManagerAsync::setPermission,
1149                   dbc.alias("alias3"),
1150                   TEST_LABEL,
1151                   CKM::Permission::READ | CKM::Permission::REMOVE);
1152
1153     {
1154         ScopedLabel label(TEST_LABEL);
1155
1156         test_negative(&ManagerAsync::getData, CKM_API_ERROR_DB_ALIAS_UNKNOWN, dbc.alias("alias"), "");
1157         test_negative(&ManagerAsync::removeAlias, CKM_API_ERROR_DB_ALIAS_UNKNOWN, dbc.alias("alias"));
1158
1159         // test from allowed label, but without properly addressing alias (coming from default label)
1160         test_negative(&ManagerAsync::getData, CKM_API_ERROR_DB_ALIAS_UNKNOWN, dbc.alias("alias2"), "");
1161
1162         // now test with appropriate addressing
1163         std::string full_alias2_address = aliasWithLabel(top_label.get(), dbc.alias("alias2"));
1164         test_positive(&ManagerAsync::getData, full_alias2_address, "");
1165         test_negative(&ManagerAsync::removeAlias, CKM_API_ERROR_ACCESS_DENIED, full_alias2_address);
1166
1167         std::string full_alias3_address = aliasWithLabel(top_label.get(), dbc.alias("alias3"));
1168         test_positive(&ManagerAsync::getData, full_alias3_address, "");
1169         test_positive(&ManagerAsync::removeAlias, full_alias3_address);
1170     }
1171 }
1172
1173 // denyAccess
1174 RUNNER_CHILD_TEST(TA1910_deny_access_invalid_param)
1175 {
1176     switch_to_storage_user(TEST_LABEL);
1177
1178     test_no_observer(&ManagerAsync::setPermission, "alias", "accessor", CKM::Permission::NONE);
1179     test_invalid_param(&ManagerAsync::setPermission, "", "accessor", CKM::Permission::NONE);
1180     test_invalid_param(&ManagerAsync::setPermission, "alias", "", CKM::Permission::NONE);
1181 }
1182
1183 RUNNER_TEST(TA1920_deny_access)
1184 {
1185     DBCleanup dbc;
1186     CharPtr top_label = get_label();
1187     test_positive(&ManagerAsync::saveData, dbc.alias("alias"), test_buffer, Policy());
1188     test_positive(&ManagerAsync::setPermission,
1189                   dbc.alias("alias"),
1190                   TEST_LABEL,
1191                   CKM::Permission::READ | CKM::Permission::REMOVE);
1192     test_positive(&ManagerAsync::setPermission, dbc.alias("alias"), TEST_LABEL, CKM::Permission::NONE);
1193
1194     {
1195         ScopedLabel label(TEST_LABEL);
1196
1197         std::string full_alias_address = aliasWithLabel(top_label.get(), dbc.alias("alias"));
1198         test_negative(&ManagerAsync::getData, CKM_API_ERROR_DB_ALIAS_UNKNOWN, full_alias_address, "");
1199         test_negative(&ManagerAsync::removeAlias, CKM_API_ERROR_DB_ALIAS_UNKNOWN, full_alias_address);
1200     }
1201 }
1202
1203 namespace
1204 {
1205 CKM::Alias alias_PKCS_exportable = "async-test-PKCS-export";
1206 CKM::Alias alias_PKCS_not_exportable = "async-test-PKCS-no-export";
1207 }
1208
1209 RUNNER_TEST(TA2000_PKCS_add_bundle_with_chain_certs)
1210 {
1211     DBCleanup dbc;
1212     auto manager = CKM::Manager::create();
1213     std::ifstream is("/usr/share/ckm-test/pkcs.p12");
1214     std::istreambuf_iterator<char> begin(is), end;
1215     std::vector<char> buff(begin, end);
1216
1217     CKM::RawBuffer buffer(buff.size());
1218     memcpy(buffer.data(), buff.data(), buff.size());
1219
1220     auto pkcs = CKM::PKCS12::create(buffer, CKM::Password());
1221     RUNNER_ASSERT_MSG(
1222         NULL != pkcs.get(),
1223         "Error in PKCS12::create()");
1224
1225     auto cert = pkcs->getCertificate();
1226     RUNNER_ASSERT_MSG(
1227         NULL != cert.get(),
1228         "Error in PKCS12::getCertificate()");
1229
1230     auto key = pkcs->getKey();
1231     RUNNER_ASSERT_MSG(
1232         NULL != key.get(),
1233         "Error in PKCS12::getKey()");
1234
1235     auto caVector = pkcs->getCaCertificateShPtrVector();
1236     RUNNER_ASSERT_MSG(
1237         2 == caVector.size(),
1238         "Wrong size of vector");
1239
1240     // save to the CKM
1241     CKM::Policy exportable;
1242     CKM::Policy notExportable(CKM::Password(), false);
1243
1244     test_positive(&ManagerAsync::savePKCS12,
1245                   alias_PKCS_exportable,
1246                   pkcs,
1247                   exportable,
1248                   exportable);
1249     test_negative(&ManagerAsync::savePKCS12,
1250                   CKM_API_ERROR_DB_ALIAS_EXISTS,
1251                   alias_PKCS_exportable,
1252                   pkcs,
1253                   exportable,
1254                   exportable);
1255
1256     test_positive(&ManagerAsync::savePKCS12,
1257                   alias_PKCS_not_exportable,
1258                   pkcs,
1259                   notExportable,
1260                   notExportable);
1261     test_negative(&ManagerAsync::savePKCS12,
1262                   CKM_API_ERROR_DB_ALIAS_EXISTS,
1263                   alias_PKCS_not_exportable,
1264                   pkcs,
1265                   notExportable,
1266                   notExportable);
1267 }
1268
1269 RUNNER_TEST(TA2010_PKCS_get)
1270 {
1271     DBCleanup dbc;
1272     auto manager = CKM::Manager::create();
1273
1274     // fail - no entry
1275     test_negative(&ManagerAsync::getPKCS12,
1276                   CKM_API_ERROR_DB_ALIAS_UNKNOWN,
1277                   "i-do-not-exist",
1278                   CKM::Password(),
1279                   CKM::Password());
1280
1281
1282     // fail - not exportable
1283     test_negative(&ManagerAsync::getPKCS12,
1284                   CKM_API_ERROR_NOT_EXPORTABLE,
1285                   dbc.alias(alias_PKCS_not_exportable.c_str()),
1286                   CKM::Password(),
1287                   CKM::Password());
1288
1289     // success - exportable
1290     auto obs = test_positive(&ManagerAsync::getPKCS12,
1291                              dbc.alias(alias_PKCS_exportable.c_str()),
1292                              CKM::Password(),
1293                              CKM::Password());
1294
1295     auto cert = obs->m_pkcs->getCertificate();
1296     RUNNER_ASSERT_MSG(
1297         NULL != cert.get(),
1298         "Error in PKCS12::getCertificate()");
1299
1300     auto key = obs->m_pkcs->getKey();
1301     RUNNER_ASSERT_MSG(
1302         NULL != key.get(),
1303         "Error in PKCS12::getKey()");
1304
1305     auto caVector = obs->m_pkcs->getCaCertificateShPtrVector();
1306     RUNNER_ASSERT_MSG(
1307         2 == caVector.size(),
1308         "Wrong size of vector");
1309 }
1310
1311 RUNNER_TEST(TA9999_deinit)
1312 {
1313     int temp;
1314     ControlShPtr control = Control::create();
1315     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == (temp = control->lockUserKey(APP_UID)),
1316                          "Error=" << ErrorToString(temp));
1317     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == (temp = control->removeUserData(APP_UID)),
1318                          "Error=" << ErrorToString(temp));
1319
1320     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == (temp = control->lockUserKey(0)),
1321                          "Error=" << ErrorToString(temp));
1322     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == (temp = control->removeUserData(0)),
1323                          "Error=" << ErrorToString(temp));
1324 }