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