src/ckm/test-certs.cpp

   1 /*
   2  *  Copyright (c) 2015 - 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       test-certs.cpp
  18  * @author     Maciej J. Karpiuk (m.karpiuk2@samsung.com)
  19  * @version    1.0
  20  */
  21
  22 #include <map>
  23 #include <memory>
  24 #include <openssl/pem.h>
  25 #include <openssl/bio.h>
  26 #include <openssl/x509.h>
  27 #include <test-certs.h>
  28 #include <dpl/test/test_runner.h>
  29 #include <dpl/test/test_runner_child.h>
  30
  31 using namespace std;
  32
  33 namespace TestData {
  34 namespace {
  35
  36 enum RawCertificateID {
  37     // test certificates
  38     TEST_ROOT_CA = 0,    // TEST_ROOT_CA, expires 2035
  39     TEST_IM_CA,          // TEST_IM_CA, signed by TEST_ROOT_CA, expires 2035
  40     TEST_LEAF,           // TEST_LEAF, signed by TEST_IM_CA, expires 2035
  41
  42     // ocsp available chain on third party
  43     GLOBALSIGN_ROOT_CA,  // GlobalSign Root CA, expires Jan 28 2028
  44     GTS_ROOT_R1,         // Google GTS Root R1, signed by GlobalSign Root CA,
  45                          // expires Jan 28 2028
  46
  47     // footer - last element in the set
  48     NO_CERT
  49 };
  50
  51
  52 struct TestCert {
  53     enum Validity {
  54         UNKNOWN,
  55         VALID,
  56         NOT_YET_VALID,
  57         EXPIRED
  58     };
  59
  60     TestCert() : valid(UNKNOWN) {}
  61
  62     string raw_base64;
  63     CKM::CertificateShPtr certPtr;
  64     Validity valid;
  65 };
  66
  67 typedef map<RawCertificateID, TestCert> CertMap;
  68
  69 CKM::CertificateShPtr createCert(const string& cert) {
  70     CKM::RawBuffer buffer_cert(cert.begin(), cert.end());
  71     CKM::CertificateShPtr cptr = CKM::Certificate::create(buffer_cert, CKM::DataFormat::FORM_PEM);
  72     return cptr;
  73 }
  74
  75 RawCertificateID toRawCertificateID(certificateID id)
  76 {
  77     switch (id) {
  78     case certificateID::TEST_ROOT_CA:        return RawCertificateID::TEST_ROOT_CA;
  79     case certificateID::TEST_IM_CA:          return RawCertificateID::TEST_IM_CA;
  80     case certificateID::TEST_LEAF:           return RawCertificateID::TEST_LEAF;
  81
  82     case certificateID::OCSP_ROOT_CA:        return RawCertificateID::GLOBALSIGN_ROOT_CA;
  83     case certificateID::OCSP_AVAILABLE_IM:   return RawCertificateID::GTS_ROOT_R1;
  84
  85     case certificateID::NO_CERT:             return RawCertificateID::NO_CERT;
  86     default: throw std::invalid_argument("Invalid raw certificat ID!");
  87     }
  88 }
  89
  90 CertMap initializeTestCerts()
  91 {
  92     CertMap cm;
  93
  94     // TEST_ROOT_CA, expires 2035
  95     {
  96         std::string raw_base64 = std::string(
  97             "-----BEGIN CERTIFICATE-----\n"
  98             "MIIDnzCCAoegAwIBAgIJAMH/ADkC5YSTMA0GCSqGSIb3DQEBBQUAMGYxCzAJBgNV\n"
  99             "BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMQ0wCwYDVQQKDARBQ01FMRAwDgYD\n"
 100             "VQQLDAdUZXN0aW5nMSEwHwYDVQQDDBhUZXN0IHJvb3QgY2EgY2VydGlmaWNhdGUw\n"
 101             "HhcNMTQxMjMwMTcyMTUyWhcNMjQxMjI3MTcyMTUyWjBmMQswCQYDVQQGEwJBVTET\n"
 102             "MBEGA1UECAwKU29tZS1TdGF0ZTENMAsGA1UECgwEQUNNRTEQMA4GA1UECwwHVGVz\n"
 103             "dGluZzEhMB8GA1UEAwwYVGVzdCByb290IGNhIGNlcnRpZmljYXRlMIIBIjANBgkq\n"
 104             "hkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0EJRdUtd2th0vTVF7QxvDKzyFCF3w9vC\n"
 105             "9IDE/Yr12w+a9jd0s7/eG96qTHIYffS3B7x2MB+d4n+SR3W0qmYh7xk8qfEgH3da\n"
 106             "eDoV59IZ9r543KM+g8jm6KffYGX1bIJVVY5OhBRbO9nY6byYpd5kbCIUB6dCf7/W\n"
 107             "rQl1aIdLGFIegAzPGFPXDcU6F192686x54bxt/itMX4agHJ9ZC/rrTBIZghVsjJo\n"
 108             "5/AH5WZpasv8sfrGiiohAxtieoYoJkv5MOYP4/2lPlOY+Cgw1Yoz+HHv31AllgFs\n"
 109             "BquBb/kJVmCCNsAOcnvQzTZUsW/TXz9G2nwRdqI1nSy2JvVjZGsqGQIDAQABo1Aw\n"
 110             "TjAdBgNVHQ4EFgQUt6pkzFt1PZlfYRL/HGnufF4frdwwHwYDVR0jBBgwFoAUt6pk\n"
 111             "zFt1PZlfYRL/HGnufF4frdwwDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQUFAAOC\n"
 112             "AQEAld7Qwq0cdzDQ51w1RVLwTR8Oy25PB3rzwEHcSGJmdqlMi3xOdaz80S1R1BBX\n"
 113             "ldvGBG5Tn0vT7xSuhmSgI2/HnBpy9ocHVOmhtNB4473NieEpfTYrnGXrFxu46Wus\n"
 114             "9m/ZnugcQ2G6C54A/NFtvgLmaC8uH8M7gKdS6uYUwJFQEofkjmd4UpOYSqmcRXhS\n"
 115             "Jzd5FYFWkJhKJYp3nlENSOD8CUFFVGekm05nFN2gRVc/qaqQkEX77+XYvhodLRsV\n"
 116             "qMn7nf7taidDKLO2T4bhujztnTYOhhaXKgPy7AtZ28N2wvX96VyAPB/vrchGmyBK\n"
 117             "kOg11TpPdNDkhb1J4ZCh2gupDg==\n"
 118             "-----END CERTIFICATE-----\n");
 119         cm[RawCertificateID::TEST_ROOT_CA].raw_base64 = raw_base64;
 120         cm[RawCertificateID::TEST_ROOT_CA].certPtr = createCert(raw_base64);
 121     }
 122
 123     // TEST_IM_CA, signed by TEST_ROOT_CA, expires 2035
 124     {
 125         std::string raw_base64 = std::string(
 126             "-----BEGIN CERTIFICATE-----\n"
 127             "MIIDljCCAn6gAwIBAgICEAAwDQYJKoZIhvcNAQEFBQAwZjELMAkGA1UEBhMCQVUx\n"
 128             "EzARBgNVBAgMClNvbWUtU3RhdGUxDTALBgNVBAoMBEFDTUUxEDAOBgNVBAsMB1Rl\n"
 129             "c3RpbmcxITAfBgNVBAMMGFRlc3Qgcm9vdCBjYSBjZXJ0aWZpY2F0ZTAeFw0xNTAx\n"
 130             "MTYxNjQ1MzRaFw0zNTAxMTExNjQ1MzRaMGQxCzAJBgNVBAYTAkFVMRMwEQYDVQQI\n"
 131             "DApTb21lLVN0YXRlMQ0wCwYDVQQKDARBQ01FMRAwDgYDVQQLDAdUZXN0aW5nMR8w\n"
 132             "HQYDVQQDDBZUZXN0IElNIENBIGNlcnRpZmljYXRlMIIBIjANBgkqhkiG9w0BAQEF\n"
 133             "AAOCAQ8AMIIBCgKCAQEAzmBF78qClgoKfnLAncMXZwZ14TW+5kags1+QCYeg3c7j\n"
 134             "L9+RvDxIaX2tKf1sukJcwQfYqUlQkwt+58LMOb2ORtkpj8Or6WCWCZ0BzneT8ug7\n"
 135             "nxJT4m9+bohMF0JoKjjB2H4KNMHamLIwUxRKt6nyfk81kVhJOi2vzzxd+UCPi6Pc\n"
 136             "UAbJNH48eNgOIg55nyFovVzYj8GIo/9GvHJj83PPa/KlJZ+Z1qZASZZ/VYorplVT\n"
 137             "thsHXKfejhFy5YJ9t7n/vyAQsyBsagZsvX19xnH41fbYXHKf8UbXG23rNaZlchs6\n"
 138             "XJVLQdzOpj3WTj/lCocVHqLaZISLhNQ3aI7kUBUdiwIDAQABo1AwTjAdBgNVHQ4E\n"
 139             "FgQUoCYNaCBP4jl/3SYQuK8Ka+6i3QEwHwYDVR0jBBgwFoAUt6pkzFt1PZlfYRL/\n"
 140             "HGnufF4frdwwDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEAjRzWiD97\n"
 141             "Htv4Kxpm3P+C+xP9AEteCJfO+7p8MWgtWEJOknJyt55zeKS2JwZIq57KcbqD8U7v\n"
 142             "vAUx1ymtUhlFPFd7J1mJ3pou+3aFYmGShYhGHpbrmUwjp7HVP588jrW1NoZVHdMc\n"
 143             "4OgJWFrViXeu9+maIcekjMB/+9Y0dUgQuK5ZuT5H/Jwet7Th/o9uufTUZjBzRvrB\n"
 144             "pbXgQpqgME2av4Q/6LuldPCTHLtWXgFUU2R+yCGmuGilvhFJnKoQryAbYnIQNWE8\n"
 145             "SLoHQ9s1i7Zyb7HU6UAaqMOz15LBkyAqtNyJcO2p7Q/p5YK0xfD4xisI5qXucqVm\n"
 146             "F2obL5qJSTN/RQ==\n"
 147             "-----END CERTIFICATE-----\n");
 148         cm[RawCertificateID::TEST_IM_CA].raw_base64 = raw_base64;
 149         cm[RawCertificateID::TEST_IM_CA].certPtr = createCert(raw_base64);
 150     }
 151
 152     // TEST_LEAF, signed by TEST_IM_CA, expires 2035
 153     {
 154         std::string raw_base64 = std::string(
 155             "-----BEGIN CERTIFICATE-----\n"
 156             "MIIDOzCCAiMCAQEwDQYJKoZIhvcNAQEFBQAwZDELMAkGA1UEBhMCQVUxEzARBgNV\n"
 157             "BAgMClNvbWUtU3RhdGUxDTALBgNVBAoMBEFDTUUxEDAOBgNVBAsMB1Rlc3Rpbmcx\n"
 158             "HzAdBgNVBAMMFlRlc3QgSU0gQ0EgY2VydGlmaWNhdGUwHhcNMTUwMTE2MTY0ODE0\n"
 159             "WhcNMzUwMTExMTY0ODE0WjBjMQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1T\n"
 160             "dGF0ZTENMAsGA1UECgwEQUNNRTEQMA4GA1UECwwHVGVzdGluZzEeMBwGA1UEAwwV\n"
 161             "VGVzdCBsZWFmIGNlcnRpZmljYXRlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB\n"
 162             "CgKCAQEAzTdDIa2tDmRxFnIgiG+mBz8GoSVODs0ImNQGbqj+pLhBOFRH8fsah4Jl\n"
 163             "z5YF9KwhMVLknnHGFLE/Nb7Ac35kEzhMQMpTRxohW83oxw3eZ8zN/FBoKqg4qHRq\n"
 164             "QR8kS10YXTgrBR0ex/Vp+OUKEw6h7yL2r4Tpvrn9/qHwsxtLxqWbDIVf1O9b1Lfc\n"
 165             "bllYMdmV5E62yN5tcwrDP8gvHjFnVeLzrG8wTpc9FR90/0Jkfp5jAJcArOBLrT0E\n"
 166             "4VRqs+4HuwT8jAwFAmNnc7IYX5qSjtSWkmmHe73K/lzB+OiI0JEc/3eWUTWqwTSk\n"
 167             "4tNCiQGBKJ39LXPTBBJdzmxVH7CUDQIDAQABMA0GCSqGSIb3DQEBBQUAA4IBAQAp\n"
 168             "UdDOGu3hNiG+Vn10aQ6B1ZmOj3t+45gUV3sC+y8hB8EK1g4P5Ke9bVDts0T5eOnj\n"
 169             "CSc+6VoND5O4adI0IFFRFljHNVnvjeosHfUZNnowsmA2ptQBtC1g5ZKRvKXlkC5/\n"
 170             "i5BGgRqPFA7y9WB9Y05MrJHf3E+Oz/RBsLeeNiNN+rF5X1vYExvGHpo0M0zS0ze9\n"
 171             "HtC0aOy8ocsTrQkf3ceHTAXx2i8ftoSSD4klojtWFpWMrNQa52F7wB9nU6FfKRuF\n"
 172             "Zj/T1JkYXKkEwZU6nAR2jdZp3EP9xj3o15V/tyFcXHx6l8NTxn4cJb+Xe4VquQJz\n"
 173             "6ON7PVe0ABN/AlwVQiFE\n"
 174             "-----END CERTIFICATE-----\n");
 175         cm[RawCertificateID::TEST_LEAF].raw_base64 = raw_base64;
 176         cm[RawCertificateID::TEST_LEAF].certPtr = createCert(raw_base64);
 177     }
 178
 179     // GlobalSign Root CA, expires Jan 28 2028
 180     {
 181         std::string raw_base64(
 182             "-----BEGIN CERTIFICATE-----\n"
 183             "MIIDdTCCAl2gAwIBAgILBAAAAAABFUtaw5QwDQYJKoZIhvcNAQEFBQAwVzELMAkG\n"
 184             "A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv\n"
 185             "b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw05ODA5MDExMjAw\n"
 186             "MDBaFw0yODAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i\n"
 187             "YWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9iYWxT\n"
 188             "aWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZ\n"
 189             "jc6j40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavp\n"
 190             "xy0Sy6scTHAHoT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp\n"
 191             "1Wrjsok6Vjk4bwY8iGlbKk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdG\n"
 192             "snUOhugZitVtbNV4FpWi6cgKOOvyJBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJ\n"
 193             "U26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FGqkjWZCrXgzT/LCrBbBlDSgeF59N8\n"
 194             "9iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E\n"
 195             "BTADAQH/MB0GA1UdDgQWBBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0B\n"
 196             "AQUFAAOCAQEA1nPnfE920I2/7LqivjTFKDK1fPxsnCwrvQmeU79rXqoRSLblCKOz\n"
 197             "yj1hTdNGCbM+w6DjY1Ub8rrvrTnhQ7k4o+YviiY776BQVvnGCv04zcQLcFGUl5gE\n"
 198             "38NflNUVyRRBnMRddWQVDf9VMOyGj/8N7yy5Y0b2qvzfvGn9LhJIZJrglfCm7ymP\n"
 199             "AbEVtQwdpf5pLGkkeB6zpxxxYu7KyJesF12KwvhHhm4qxFYxldBniYUr+WymXUad\n"
 200             "DKqC5JlR3XC321Y9YeRq4VzW9v493kHMB65jUr9TU/Qr6cf9tveCX4XSQRjbgbME\n"
 201             "HMUfpIBvFSDJ3gyICh3WZlXi/EjJKSZp4A==\n"
 202             "-----END CERTIFICATE-----\n"
 203             );
 204         cm[RawCertificateID::GLOBALSIGN_ROOT_CA].raw_base64 = raw_base64;
 205         cm[RawCertificateID::GLOBALSIGN_ROOT_CA].certPtr = createCert(raw_base64);
 206     }
 207
 208     // Google GTS Root R1, signed by GlobalSign Root CA, expires Jan 28 2028
 209     {
 210         std::string raw_base64(
 211             "-----BEGIN CERTIFICATE-----\n"
 212             "MIIFYjCCBEqgAwIBAgIQd70NbNs2+RrqIQ/E8FjTDTANBgkqhkiG9w0BAQsFADBX\n"
 213             "MQswCQYDVQQGEwJCRTEZMBcGA1UEChMQR2xvYmFsU2lnbiBudi1zYTEQMA4GA1UE\n"
 214             "CxMHUm9vdCBDQTEbMBkGA1UEAxMSR2xvYmFsU2lnbiBSb290IENBMB4XDTIwMDYx\n"
 215             "OTAwMDA0MloXDTI4MDEyODAwMDA0MlowRzELMAkGA1UEBhMCVVMxIjAgBgNVBAoT\n"
 216             "GUdvb2dsZSBUcnVzdCBTZXJ2aWNlcyBMTEMxFDASBgNVBAMTC0dUUyBSb290IFIx\n"
 217             "MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAthECix7joXebO9y/lD63\n"
 218             "ladAPKH9gvl9MgaCcfb2jH/76Nu8ai6Xl6OMS/kr9rH5zoQdsfnFl97vufKj6bwS\n"
 219             "iV6nqlKr+CMny6SxnGPb15l+8Ape62im9MZaRw1NEDPjTrETo8gYbEvs/AmQ351k\n"
 220             "KSUjB6G00j0uYODP0gmHu81I8E3CwnqIiru6z1kZ1q+PsAewnjHxgsHA3y6mbWwZ\n"
 221             "DrXYfiYaRQM9sHmklCitD38m5agI/pboPGiUU+6DOogrFZYJsuB6jC511pzrp1Zk\n"
 222             "j5ZPaK49l8KEj8C8QMALXL32h7M1bKwYUH+E4EzNktMg6TO8UpmvMrUpsyUqtEj5\n"
 223             "cuHKZPfmghCN6J3Cioj6OGaK/GP5Afl4/Xtcd/p2h/rs37EOeZVXtL0m79YB0esW\n"
 224             "CruOC7XFxYpVq9Os6pFLKcwZpDIlTirxZUTQAs6qzkm06p98g7BAe+dDq6dso499\n"
 225             "iYH6TKX/1Y7DzkvgtdizjkXPdsDtQCv9Uw+wp9U7DbGKogPeMa3Md+pvez7W35Ei\n"
 226             "Eua++tgy/BBjFFFy3l3WFpO9KWgz7zpm7AeKJt8T11dleCfeXkkUAKIAf5qoIbap\n"
 227             "sZWwpbkNFhHax2xIPEDgfg1azVY80ZcFuctL7TlLnMQ/0lUTbiSw1nH69MG6zO0b\n"
 228             "9f6BQdgAmD06yK56mDcYBZUCAwEAAaOCATgwggE0MA4GA1UdDwEB/wQEAwIBhjAP\n"
 229             "BgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTkrysmcRorSCeFL1JmLO/wiRNxPjAf\n"
 230             "BgNVHSMEGDAWgBRge2YaRQ2XyolQL30EzTSo//z9SzBgBggrBgEFBQcBAQRUMFIw\n"
 231             "JQYIKwYBBQUHMAGGGWh0dHA6Ly9vY3NwLnBraS5nb29nL2dzcjEwKQYIKwYBBQUH\n"
 232             "MAKGHWh0dHA6Ly9wa2kuZ29vZy9nc3IxL2dzcjEuY3J0MDIGA1UdHwQrMCkwJ6Al\n"
 233             "oCOGIWh0dHA6Ly9jcmwucGtpLmdvb2cvZ3NyMS9nc3IxLmNybDA7BgNVHSAENDAy\n"
 234             "MAgGBmeBDAECATAIBgZngQwBAgIwDQYLKwYBBAHWeQIFAwIwDQYLKwYBBAHWeQIF\n"
 235             "AwMwDQYJKoZIhvcNAQELBQADggEBADSkHrEoo9C0dhemMXoh6dFSPsjbdBZBiLg9\n"
 236             "NR3t5P+T4Vxfq7vqfM/b5A3Ri1fyJm9bvhdGaJQ3b2t6yMAYN/olUazsaL+yyEn9\n"
 237             "WprKASOshIArAoyZl+tJaox118fessmXn1hIVw41oeQa1v1vg4Fv74zPl6/AhSrw\n"
 238             "9U5pCZEt4Wi4wStz6dTZ/CLANx8LZh1J7QJVj2fhMtfTJr9w4z30Z209fOU0iOMy\n"
 239             "+qduBmpvvYuR7hZL6Dupszfnw0Skfths18dG9ZKb59UhvmaSGZRVbNQpsg3BZlvi\n"
 240             "d0lIKO2d1xozclOzgjXPYovJJIultzkMu34qQb9Sz/yilrbCgj8=\n"
 241             "-----END CERTIFICATE-----\n"
 242             );
 243         cm[RawCertificateID::GTS_ROOT_R1].raw_base64 = raw_base64;
 244         cm[RawCertificateID::GTS_ROOT_R1].certPtr = createCert(raw_base64);
 245     }
 246
 247     return cm;
 248 }
 249
 250 CertMap TEST_CERTS = initializeTestCerts();
 251
 252 } // namespace TestData::anonymous
 253
 254 void checkCertificateValidity(std::map<RawCertificateID, TestCert>::iterator& it)
 255 {
 256     if (it->second.valid == TestCert::UNKNOWN)
 257     {
 258         auto buff = BIO_new(BIO_s_mem());
 259         BIO_write(buff, it->second.raw_base64.c_str(), it->second.raw_base64.size());
 260
 261         X509* x509 = PEM_read_bio_X509(buff, nullptr, nullptr, nullptr);
 262         BIO_free_all(buff);
 263
 264         RUNNER_ASSERT_MSG(x509 != NULL, "Test certificate " << it->first << " can't be parsed");
 265
 266         if (X509_cmp_current_time(X509_get_notBefore(x509)) > 0)
 267             it->second.valid = TestCert::NOT_YET_VALID;
 268         else if (X509_cmp_current_time(X509_get_notAfter(x509)) < 0)
 269             it->second.valid = TestCert::EXPIRED;
 270         else
 271             it->second.valid = TestCert::VALID;
 272
 273         X509_free(x509);
 274     }
 275
 276     switch (it->second.valid)
 277     {
 278     case TestCert::NOT_YET_VALID:
 279         RUNNER_FAIL_MSG(
 280                 "Test certificate " << it->first <<
 281                 " is not yet valid. Check the certificate and the system date.");
 282         break;
 283     case TestCert::EXPIRED:
 284         RUNNER_FAIL_MSG(
 285                 "Test certificate " << it->first <<
 286                 " has expired. Check the certificate and the system date.");
 287         break;
 288     default:
 289         break;
 290     }
 291 }
 292
 293 std::string getTestCertificateBase64(certificateID id)
 294 {
 295     auto cert = TEST_CERTS.find(toRawCertificateID(id));
 296
 297     RUNNER_ASSERT_MSG(cert != TEST_CERTS.end(), "Unknown certificate index!");
 298
 299     auto &certStruct = cert->second;
 300     RUNNER_ASSERT_MSG(certStruct.raw_base64.size() > 0, "Certificate is empty!");
 301
 302     checkCertificateValidity(cert);
 303
 304     return certStruct.raw_base64;
 305 }
 306
 307 CKM::CertificateShPtr getTestCertificate(certificateID id)
 308 {
 309     auto cert = TEST_CERTS.find(toRawCertificateID(id));
 310
 311     RUNNER_ASSERT_MSG(cert != TEST_CERTS.end(), "Unknown certificate index!");
 312
 313     auto &certStruct = cert->second;
 314     RUNNER_ASSERT_MSG(certStruct.certPtr != nullptr, "Certificate is empty!");
 315
 316     checkCertificateValidity(cert);
 317
 318     return certStruct.certPtr;
 319 }
 320
 321 } // namespace TestData