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