src/ckm/unprivileged/async-api.cpp

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