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