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