tests/capi/test_suite_01.cpp

   1 /*
   2  * Copyright (c) 2011 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 #include <string>
  17
  18 #include <openssl/x509.h>
  19
  20 #include <dpl/test/test_runner.h>
  21 #include <dpl/log/log.h>
  22
  23 #include <api_tests.h>
  24
  25 RUNNER_TEST_GROUP_INIT(CAPI)
  26
  27 /*
  28  * author:      ---
  29  * test:        New certificate from file.
  30  * description: Creating new certificate using *.pem file.
  31  * expect:      Certificate should be created and has correct string inside..
  32  */
  33 RUNNER_TEST(test01_certificate_new_from_file)
  34 {
  35     CertSvcCertificate cert;
  36     int result = certsvc_certificate_new_from_file(
  37         vinstance,
  38         "/usr/share/ca-certificates/wac/root_cacert0.pem",
  39         &cert);
  40     RUNNER_ASSERT_MSG(CERTSVC_TRUE == result, "Error reading certificate");
  41
  42     CertSvcString string;
  43
  44     certsvc_certificate_get_string_field(
  45         cert,
  46         CERTSVC_SUBJECT_COMMON_NAME,
  47         &string);
  48
  49     const char *ptr = "Samsung";
  50
  51     const char *buffer;
  52     size_t len;
  53
  54     certsvc_string_to_cstring(string, &buffer, &len);
  55
  56     result = strncmp(
  57         buffer,
  58         ptr,
  59         strlen(ptr));
  60
  61     RUNNER_ASSERT_MSG(0 == result, "Error reading common name");
  62
  63     certsvc_certificate_free(cert);
  64 }
  65
  66 /*
  67  * author:      ---
  68  * test:        Searching certificate.
  69  * description: Searching for certificate with specified value.
  70  * expect:      Found certificate should had correct string inside.
  71  */
  72 RUNNER_TEST(test02_certificate_search)
  73 {
  74     CertSvcCertificateList handler;
  75     int result = certsvc_certificate_search(vinstance,
  76                                           CERTSVC_SUBJECT_COMMON_NAME,
  77                                           "WAC Application Services Ltd",
  78                                           &handler);
  79
  80     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in search method. errcode : " << result);
  81
  82     CertSvcCertificate cert;
  83
  84     result = certsvc_certificate_list_get_one(handler, 0, &cert);
  85
  86     RUNNER_ASSERT_MSG(CERTSVC_TRUE == result, "Error reading certificate. errcode : " << result);
  87
  88     CertSvcString string;
  89
  90     certsvc_certificate_get_string_field(
  91         cert,
  92         CERTSVC_SUBJECT_COUNTRY_NAME,
  93         &string);
  94
  95     const char *ptr = "GB";
  96     const char *buffer;
  97
  98     certsvc_string_to_cstring(string, &buffer, NULL);
  99
 100     result = strncmp(
 101             buffer,
 102             ptr,
 103             strlen(ptr));
 104
 105     RUNNER_ASSERT_MSG(0 == result, "Country does not match. result : " << result);
 106 }
 107
 108 /*
 109  * author:      ---
 110  * test:        Testing certificate sign.
 111  * description: Testing if certificate is signed by proper CA.
 112  * expect:      Chain verification should return success.
 113  */
 114 RUNNER_TEST(test03_is_signed_by)
 115 {
 116     int result;
 117     std::string googleCA =
 118       "MIICPDCCAaUCEHC65B0Q2Sk0tjjKewPMur8wDQYJKoZIhvcNAQECBQAwXzELMAkG"
 119       "A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFz"
 120       "cyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTk2"
 121       "MDEyOTAwMDAwMFoXDTI4MDgwMTIzNTk1OVowXzELMAkGA1UEBhMCVVMxFzAVBgNV"
 122       "BAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFzcyAzIFB1YmxpYyBQcmlt"
 123       "YXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGfMA0GCSqGSIb3DQEBAQUAA4GN"
 124       "ADCBiQKBgQDJXFme8huKARS0EN8EQNvjV69qRUCPhAwL0TPZ2RHP7gJYHyX3KqhE"
 125       "BarsAx94f56TuZoAqiN91qyFomNFx3InzPRMxnVx0jnvT0Lwdd8KkMaOIG+YD/is"
 126       "I19wKTakyYbnsZogy1Olhec9vn2a/iRFM9x2Fe0PonFkTGUugWhFpwIDAQABMA0G"
 127       "CSqGSIb3DQEBAgUAA4GBALtMEivPLCYATxQT3ab7/AoRhIzzKBxnki98tsX63/Do"
 128       "lbwdj2wsqFHMc9ikwFPwTtYmwHYBV4GSXiHx0bH/59AhWM1pF+NEHJwZRDmJXNyc"
 129       "AA9WjQKZ7aKQRUzkuxCkPfAyAw7xzvjoyVGM5mKf5p/AfbdynMk2OmufTqj/ZA1k";
 130
 131     std::string google2nd =
 132       "MIIDIzCCAoygAwIBAgIEMAAAAjANBgkqhkiG9w0BAQUFADBfMQswCQYDVQQGEwJV"
 133       "UzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xNzA1BgNVBAsTLkNsYXNzIDMgUHVi"
 134       "bGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQwNTEzMDAw"
 135       "MDAwWhcNMTQwNTEyMjM1OTU5WjBMMQswCQYDVQQGEwJaQTElMCMGA1UEChMcVGhh"
 136       "d3RlIENvbnN1bHRpbmcgKFB0eSkgTHRkLjEWMBQGA1UEAxMNVGhhd3RlIFNHQyBD"
 137       "QTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA1NNn0I0Vf67NMf59HZGhPwtx"
 138       "PKzMyGT7Y/wySweUvW+Aui/hBJPAM/wJMyPpC3QrccQDxtLN4i/1CWPN/0ilAL/g"
 139       "5/OIty0y3pg25gqtAHvEZEo7hHUD8nCSfQ5i9SGraTaEMXWQ+L/HbIgbBpV8yeWo"
 140       "3nWhLHpo39XKHIdYYBkCAwEAAaOB/jCB+zASBgNVHRMBAf8ECDAGAQH/AgEAMAsG"
 141       "A1UdDwQEAwIBBjARBglghkgBhvhCAQEEBAMCAQYwKAYDVR0RBCEwH6QdMBsxGTAX"
 142       "BgNVBAMTEFByaXZhdGVMYWJlbDMtMTUwMQYDVR0fBCowKDAmoCSgIoYgaHR0cDov"
 143       "L2NybC52ZXJpc2lnbi5jb20vcGNhMy5jcmwwMgYIKwYBBQUHAQEEJjAkMCIGCCsG"
 144       "AQUFBzABhhZodHRwOi8vb2NzcC50aGF3dGUuY29tMDQGA1UdJQQtMCsGCCsGAQUF"
 145       "BwMBBggrBgEFBQcDAgYJYIZIAYb4QgQBBgpghkgBhvhFAQgBMA0GCSqGSIb3DQEB"
 146       "BQUAA4GBAFWsY+reod3SkF+fC852vhNRj5PZBSvIG3dLrWlQoe7e3P3bB+noOZTc"
 147       "q3J5Lwa/q4FwxKjt6lM07e8eU9kGx1Yr0Vz00YqOtCuxN5BICEIlxT6Ky3/rbwTR"
 148       "bcV0oveifHtgPHfNDs5IAn8BL7abN+AqKjbc1YXWrOU/VG+WHgWv";
 149
 150     CertSvcCertificate cert1, cert2;
 151
 152     result = certsvc_certificate_new_from_memory(
 153         vinstance,
 154         (const unsigned char*)googleCA.c_str(),
 155         googleCA.size(),
 156         CERTSVC_FORM_DER_BASE64,
 157         &cert1);
 158
 159     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error reading certificate");
 160
 161     result = certsvc_certificate_new_from_memory(
 162         vinstance,
 163         (const unsigned char*)google2nd.c_str(),
 164         google2nd.size(),
 165         CERTSVC_FORM_DER_BASE64,
 166         &cert2);
 167
 168     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error reading certificate");
 169
 170     int status;
 171     result = certsvc_certificate_is_signed_by(cert2, cert1, &status);
 172
 173     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Chain verification failed");
 174     RUNNER_ASSERT_MSG(CERTSVC_TRUE == status, "Chain verification failed");
 175 }
 176
 177 /*
 178  * author:      ---
 179  * test:        Certificate expiring test.
 180  * description: Testing if certificate is valid before / after specified date.
 181  * expect:      Certificate should be valid before / after specified date.
 182  */
 183 RUNNER_TEST(test04_not_before_not_after)
 184 {
 185     std::string google2nd =
 186       "MIIDIzCCAoygAwIBAgIEMAAAAjANBgkqhkiG9w0BAQUFADBfMQswCQYDVQQGEwJV"
 187       "UzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xNzA1BgNVBAsTLkNsYXNzIDMgUHVi"
 188       "bGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQwNTEzMDAw"
 189       "MDAwWhcNMTQwNTEyMjM1OTU5WjBMMQswCQYDVQQGEwJaQTElMCMGA1UEChMcVGhh"
 190       "d3RlIENvbnN1bHRpbmcgKFB0eSkgTHRkLjEWMBQGA1UEAxMNVGhhd3RlIFNHQyBD"
 191       "QTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA1NNn0I0Vf67NMf59HZGhPwtx"
 192       "PKzMyGT7Y/wySweUvW+Aui/hBJPAM/wJMyPpC3QrccQDxtLN4i/1CWPN/0ilAL/g"
 193       "5/OIty0y3pg25gqtAHvEZEo7hHUD8nCSfQ5i9SGraTaEMXWQ+L/HbIgbBpV8yeWo"
 194       "3nWhLHpo39XKHIdYYBkCAwEAAaOB/jCB+zASBgNVHRMBAf8ECDAGAQH/AgEAMAsG"
 195       "A1UdDwQEAwIBBjARBglghkgBhvhCAQEEBAMCAQYwKAYDVR0RBCEwH6QdMBsxGTAX"
 196       "BgNVBAMTEFByaXZhdGVMYWJlbDMtMTUwMQYDVR0fBCowKDAmoCSgIoYgaHR0cDov"
 197       "L2NybC52ZXJpc2lnbi5jb20vcGNhMy5jcmwwMgYIKwYBBQUHAQEEJjAkMCIGCCsG"
 198       "AQUFBzABhhZodHRwOi8vb2NzcC50aGF3dGUuY29tMDQGA1UdJQQtMCsGCCsGAQUF"
 199       "BwMBBggrBgEFBQcDAgYJYIZIAYb4QgQBBgpghkgBhvhFAQgBMA0GCSqGSIb3DQEB"
 200       "BQUAA4GBAFWsY+reod3SkF+fC852vhNRj5PZBSvIG3dLrWlQoe7e3P3bB+noOZTc"
 201       "q3J5Lwa/q4FwxKjt6lM07e8eU9kGx1Yr0Vz00YqOtCuxN5BICEIlxT6Ky3/rbwTR"
 202       "bcV0oveifHtgPHfNDs5IAn8BL7abN+AqKjbc1YXWrOU/VG+WHgWv";
 203
 204     CertSvcCertificate cert;
 205     int result;
 206
 207     result = certsvc_certificate_new_from_memory(
 208         vinstance,
 209         (const unsigned char *)google2nd.c_str(),
 210         google2nd.size(),
 211         CERTSVC_FORM_DER_BASE64,
 212         &cert);
 213
 214     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error reading certificate");
 215
 216     time_t before, after;
 217     result = certsvc_certificate_get_not_before(cert, &before);
 218
 219     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error extracting NOT_BEFORE");
 220     RUNNER_ASSERT_MSG(before == 1084406400, "TODO");
 221
 222     result = certsvc_certificate_get_not_after(cert, &after);
 223
 224     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error extracting NOT_AFTER");
 225     //extracted: date --date="May 12 23:59:59 2014 GMT" +%s
 226     RUNNER_ASSERT_MSG(after == 1399939199, "TODO");
 227 }
 228
 229 /*
 230  * author:      ---
 231  * test:        Import fields from certificate.
 232  * description: Getting common name from certificate.
 233  * expect:      It should be possible to get common name from certificate.
 234  */
 235 RUNNER_TEST(test06_cert_get_field)
 236 {
 237     std::string google2nd =
 238       "MIIDIzCCAoygAwIBAgIEMAAAAjANBgkqhkiG9w0BAQUFADBfMQswCQYDVQQGEwJV"
 239       "UzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xNzA1BgNVBAsTLkNsYXNzIDMgUHVi"
 240       "bGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQwNTEzMDAw"
 241       "MDAwWhcNMTQwNTEyMjM1OTU5WjBMMQswCQYDVQQGEwJaQTElMCMGA1UEChMcVGhh"
 242       "d3RlIENvbnN1bHRpbmcgKFB0eSkgTHRkLjEWMBQGA1UEAxMNVGhhd3RlIFNHQyBD"
 243       "QTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA1NNn0I0Vf67NMf59HZGhPwtx"
 244       "PKzMyGT7Y/wySweUvW+Aui/hBJPAM/wJMyPpC3QrccQDxtLN4i/1CWPN/0ilAL/g"
 245       "5/OIty0y3pg25gqtAHvEZEo7hHUD8nCSfQ5i9SGraTaEMXWQ+L/HbIgbBpV8yeWo"
 246       "3nWhLHpo39XKHIdYYBkCAwEAAaOB/jCB+zASBgNVHRMBAf8ECDAGAQH/AgEAMAsG"
 247       "A1UdDwQEAwIBBjARBglghkgBhvhCAQEEBAMCAQYwKAYDVR0RBCEwH6QdMBsxGTAX"
 248       "BgNVBAMTEFByaXZhdGVMYWJlbDMtMTUwMQYDVR0fBCowKDAmoCSgIoYgaHR0cDov"
 249       "L2NybC52ZXJpc2lnbi5jb20vcGNhMy5jcmwwMgYIKwYBBQUHAQEEJjAkMCIGCCsG"
 250       "AQUFBzABhhZodHRwOi8vb2NzcC50aGF3dGUuY29tMDQGA1UdJQQtMCsGCCsGAQUF"
 251       "BwMBBggrBgEFBQcDAgYJYIZIAYb4QgQBBgpghkgBhvhFAQgBMA0GCSqGSIb3DQEB"
 252       "BQUAA4GBAFWsY+reod3SkF+fC852vhNRj5PZBSvIG3dLrWlQoe7e3P3bB+noOZTc"
 253       "q3J5Lwa/q4FwxKjt6lM07e8eU9kGx1Yr0Vz00YqOtCuxN5BICEIlxT6Ky3/rbwTR"
 254       "bcV0oveifHtgPHfNDs5IAn8BL7abN+AqKjbc1YXWrOU/VG+WHgWv";
 255
 256     CertSvcCertificate cert;
 257
 258     int result = certsvc_certificate_new_from_memory(
 259         vinstance,
 260         (const unsigned char*)google2nd.c_str(),
 261         google2nd.size(),
 262         CERTSVC_FORM_DER_BASE64,
 263         &cert);
 264
 265     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in reading certificate.");
 266
 267     CertSvcString subject, issuer;
 268
 269     result = certsvc_certificate_get_string_field(
 270         cert,
 271         CERTSVC_SUBJECT,
 272         &subject);
 273
 274     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in reading SUBJECT field.");
 275
 276     result = certsvc_certificate_get_string_field(
 277         cert,
 278         CERTSVC_ISSUER,
 279         &issuer);
 280
 281     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in reading ISSUER field.");
 282
 283     size_t size;
 284     const char *ptr;
 285
 286     certsvc_string_to_cstring(subject, &ptr, &size);
 287     RUNNER_ASSERT_MSG(0 == strncmp(ptr, "/C=ZA/O=Thawte Consulting (Pty) Ltd./CN=Thawte SGC CA", size), "Subject does not match.");
 288
 289     certsvc_string_to_cstring(issuer, &ptr, &size);
 290     RUNNER_ASSERT_MSG(0 == strncmp(ptr, "/C=US/O=VeriSign, Inc./OU=Class 3 Public Primary Certification Authority", size), "Issuer does not match.");
 291 }
 292
 293 /*
 294  * author:      ---
 295  * test:        Sorting certificates chain.
 296  * description: Certificate chain is being sorted.
 297  * expect:      It is possible to sor certificates chain.
 298  */
 299 RUNNER_TEST(test07_chain_sort)
 300 {
 301     std::string certEE =
 302       "MIIDIjCCAougAwIBAgIQK59+5colpiUUIEeCdTqbuTANBgkqhkiG9w0BAQUFADBM"
 303       "MQswCQYDVQQGEwJaQTElMCMGA1UEChMcVGhhd3RlIENvbnN1bHRpbmcgKFB0eSkg"
 304       "THRkLjEWMBQGA1UEAxMNVGhhd3RlIFNHQyBDQTAeFw0xMTEwMjYwMDAwMDBaFw0x"
 305       "MzA5MzAyMzU5NTlaMGkxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpDYWxpZm9ybmlh"
 306       "MRYwFAYDVQQHFA1Nb3VudGFpbiBWaWV3MRMwEQYDVQQKFApHb29nbGUgSW5jMRgw"
 307       "FgYDVQQDFA9tYWlsLmdvb2dsZS5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJ"
 308       "AoGBAK85FZho5JL+T0/xu/8NLrD+Jaq9aARnJ+psQ0ynbcvIj36B7ocmJRASVDOe"
 309       "qj2bj46Ss0sB4/lKKcMP/ay300yXKT9pVc9wgwSvLgRudNYPFwn+niAkJOPHaJys"
 310       "Eb2S5LIbCfICMrtVGy0WXzASI+JMSo3C2j/huL/3OrGGvvDFAgMBAAGjgecwgeQw"
 311       "DAYDVR0TAQH/BAIwADA2BgNVHR8ELzAtMCugKaAnhiVodHRwOi8vY3JsLnRoYXd0"
 312       "ZS5jb20vVGhhd3RlU0dDQ0EuY3JsMCgGA1UdJQQhMB8GCCsGAQUFBwMBBggrBgEF"
 313       "BQcDAgYJYIZIAYb4QgQBMHIGCCsGAQUFBwEBBGYwZDAiBggrBgEFBQcwAYYWaHR0"
 314       "cDovL29jc3AudGhhd3RlLmNvbTA+BggrBgEFBQcwAoYyaHR0cDovL3d3dy50aGF3"
 315       "dGUuY29tL3JlcG9zaXRvcnkvVGhhd3RlX1NHQ19DQS5jcnQwDQYJKoZIhvcNAQEF"
 316       "BQADgYEANYARzVI+hCn7wSjhIOUCj19xZVgdYnJXPOZeJWHTy60i+NiBpOf0rnzZ"
 317       "wW2qkw1iB5/yZ0eZNDNPPQJ09IHWOAgh6OKh+gVBnJzJ+fPIo+4NpddQVF4vfXm3"
 318       "fgp8tuIsqK7+lNfNFjBxBKqeecPStiSnJavwSI4vw6e7UN0Pz7A=";
 319
 320     std::string certCA =
 321       "MIIDIzCCAoygAwIBAgIEMAAAAjANBgkqhkiG9w0BAQUFADBfMQswCQYDVQQGEwJV"
 322       "UzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xNzA1BgNVBAsTLkNsYXNzIDMgUHVi"
 323       "bGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQwNTEzMDAw"
 324       "MDAwWhcNMTQwNTEyMjM1OTU5WjBMMQswCQYDVQQGEwJaQTElMCMGA1UEChMcVGhh"
 325       "d3RlIENvbnN1bHRpbmcgKFB0eSkgTHRkLjEWMBQGA1UEAxMNVGhhd3RlIFNHQyBD"
 326       "QTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA1NNn0I0Vf67NMf59HZGhPwtx"
 327       "PKzMyGT7Y/wySweUvW+Aui/hBJPAM/wJMyPpC3QrccQDxtLN4i/1CWPN/0ilAL/g"
 328       "5/OIty0y3pg25gqtAHvEZEo7hHUD8nCSfQ5i9SGraTaEMXWQ+L/HbIgbBpV8yeWo"
 329       "3nWhLHpo39XKHIdYYBkCAwEAAaOB/jCB+zASBgNVHRMBAf8ECDAGAQH/AgEAMAsG"
 330       "A1UdDwQEAwIBBjARBglghkgBhvhCAQEEBAMCAQYwKAYDVR0RBCEwH6QdMBsxGTAX"
 331       "BgNVBAMTEFByaXZhdGVMYWJlbDMtMTUwMQYDVR0fBCowKDAmoCSgIoYgaHR0cDov"
 332       "L2NybC52ZXJpc2lnbi5jb20vcGNhMy5jcmwwMgYIKwYBBQUHAQEEJjAkMCIGCCsG"
 333       "AQUFBzABhhZodHRwOi8vb2NzcC50aGF3dGUuY29tMDQGA1UdJQQtMCsGCCsGAQUF"
 334       "BwMBBggrBgEFBQcDAgYJYIZIAYb4QgQBBgpghkgBhvhFAQgBMA0GCSqGSIb3DQEB"
 335       "BQUAA4GBAFWsY+reod3SkF+fC852vhNRj5PZBSvIG3dLrWlQoe7e3P3bB+noOZTc"
 336       "q3J5Lwa/q4FwxKjt6lM07e8eU9kGx1Yr0Vz00YqOtCuxN5BICEIlxT6Ky3/rbwTR"
 337       "bcV0oveifHtgPHfNDs5IAn8BL7abN+AqKjbc1YXWrOU/VG+WHgWv";
 338
 339     std::string certRCA =
 340       "MIICPDCCAaUCEHC65B0Q2Sk0tjjKewPMur8wDQYJKoZIhvcNAQECBQAwXzELMAkG"
 341       "A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFz"
 342       "cyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTk2"
 343       "MDEyOTAwMDAwMFoXDTI4MDgwMTIzNTk1OVowXzELMAkGA1UEBhMCVVMxFzAVBgNV"
 344       "BAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFzcyAzIFB1YmxpYyBQcmlt"
 345       "YXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGfMA0GCSqGSIb3DQEBAQUAA4GN"
 346       "ADCBiQKBgQDJXFme8huKARS0EN8EQNvjV69qRUCPhAwL0TPZ2RHP7gJYHyX3KqhE"
 347       "BarsAx94f56TuZoAqiN91qyFomNFx3InzPRMxnVx0jnvT0Lwdd8KkMaOIG+YD/is"
 348       "I19wKTakyYbnsZogy1Olhec9vn2a/iRFM9x2Fe0PonFkTGUugWhFpwIDAQABMA0G"
 349       "CSqGSIb3DQEBAgUAA4GBALtMEivPLCYATxQT3ab7/AoRhIzzKBxnki98tsX63/Do"
 350       "lbwdj2wsqFHMc9ikwFPwTtYmwHYBV4GSXiHx0bH/59AhWM1pF+NEHJwZRDmJXNyc"
 351       "AA9WjQKZ7aKQRUzkuxCkPfAyAw7xzvjoyVGM5mKf5p/AfbdynMk2OmufTqj/ZA1k";
 352
 353     CertSvcCertificate cert1, cert2, cert3;
 354
 355     int result = certsvc_certificate_new_from_memory(
 356         vinstance,
 357         (const unsigned char*)certEE.c_str(),
 358         certEE.size(),
 359         CERTSVC_FORM_DER_BASE64,
 360         &cert1);
 361
 362     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in reading certificate.");
 363
 364     result = certsvc_certificate_new_from_memory(
 365         vinstance,
 366         (const unsigned char*)certCA.c_str(),
 367         certCA.size(),
 368         CERTSVC_FORM_DER_BASE64,
 369         &cert2);
 370     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in reading certificate.");
 371
 372     result = certsvc_certificate_new_from_memory(
 373         vinstance,
 374         (const unsigned char*)certRCA.c_str(),
 375         certRCA.size(),
 376         CERTSVC_FORM_DER_BASE64,
 377         &cert3);
 378     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in reading certificate.");
 379
 380     CertSvcCertificate collection[3];
 381     collection[0] = cert1;
 382     collection[1] = cert3;
 383     collection[2] = cert2;
 384
 385     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == certsvc_certificate_chain_sort(collection, 3), "FAIL TO SORT CERTIFICATE");
 386
 387     RUNNER_ASSERT_MSG(collection[2].privateHandler == cert3.privateHandler, "certsvc_certificate_chain_sort failed");
 388
 389     collection[0] = cert1;
 390     collection[1] = cert3;
 391
 392     RUNNER_ASSERT_MSG(CERTSVC_FAIL == certsvc_certificate_chain_sort(collection, 2), "certsvc_certificate_chain_sort failed");
 393 }
 394
 395 /*
 396  * author:      ---
 397  * test:        Verification of DSA SHA1.
 398  * description: Testing certificate DSA SH1.
 399  * expect:      Certificate DSA SH1 should be correct.
 400  */
 401 RUNNER_TEST(test08_message_verify_dsa_sha1)
 402 {
 403     std::string magda =
 404       "MIIEDzCCA3igAwIBAgIJAMdKgvadG/Z/MA0GCSqGSIb3DQEBBQUAMHIxCzAJBgNV"
 405       "BAYTAlBMMQwwCgYDVQQIEwNNYXoxEDAOBgNVBAoTB1NhbXN1bmcxDTALBgNVBAsT"
 406       "BFNQUkMxEDAOBgNVBAMTB1NhbXN1bmcxIjAgBgkqhkiG9w0BCQEWE3NhbXN1bmdA"
 407       "c2Ftc3VuZy5jb20wHhcNMTExMDA1MTIxMTMzWhcNMjExMDAyMTIxMTMzWjCBijEL"
 408       "MAkGA1UEBhMCUEwxFDASBgNVBAgTC01hem93aWVja2llMRIwEAYDVQQHEwlsZWdp"
 409       "b25vd28xEDAOBgNVBAoTB3NhbXN1bmcxDTALBgNVBAsTBHNwcmMxDjAMBgNVBAMT"
 410       "BW1hZ2RhMSAwHgYJKoZIhvcNAQkBFhFtYWdkYUBzYW1zdW5nLmNvbTCCAbcwggEr"
 411       "BgcqhkjOOAQBMIIBHgKBgQC1PCOasFhlfMc1yjdcp7zkzXGiW+MpVuFlsdYwkAa9"
 412       "sIvNrQLi2ulxcnNBeCHKDbk7U+J3/QwO2XanapQMUqvfjfjL1QQ5Vf7ENUWPNP7c"
 413       "Evx82Nb5jWdHyRfV//TciBZN8GLNEbfhtWlhI6CbDW1AaY0nPZ879rSIk7/aNKZ3"
 414       "FQIVALcr8uQAmnV+3DLIA5nTo0Bg0bjLAoGAJG7meUtQbMulRMdjzeCoya2FXdm+"
 415       "4acvInE9/+MybXTB3bFANMyw6WTvk4K9RK8tm52N95cykTjpAbxqTMaXwkdWbOFd"
 416       "VKAKnyxi/UKtY9Q6NmwJB2hbA1GUzhPko8rEda66CGl0VbyM1lKMJjA+wp9pG110"
 417       "L0ov19Q9fvqKp5UDgYUAAoGBAKxAQg7MqCgkC0MJftYjNaKM5n1iZv4j1li49zKf"
 418       "Y5nTLP+vYAvg0owLNYvJ5ncKfY1DACPU4/+tC7TTua95wgj5rwvAXnzgSyOGuSr0"
 419       "fK9DyrH6E0LfXT+WuIQHahm2iSbxqPrChlnp5/EXDTBaO6Qfdpq0BP48ClZebxcA"
 420       "+TYFo3sweTAJBgNVHRMEAjAAMCwGCWCGSAGG+EIBDQQfFh1PcGVuU1NMIEdlbmVy"
 421       "YXRlZCBDZXJ0aWZpY2F0ZTAdBgNVHQ4EFgQUmSpShswvWtEABd+l3WxccRcCydUw"
 422       "HwYDVR0jBBgwFoAUggh/2wAChuhTKqX6WK5nfxQ4yGAwDQYJKoZIhvcNAQEFBQAD"
 423       "gYEAgfnAu/gMJRC/BFwkgvrHL0TV4ffPVAf7RSnZS6ib4IHGgrvXJvL+Qh7vHykv"
 424       "ZIqD2L96nY2EaSNr0yXrT81YROndOQUJNx4Y/W8m6asu4hzANNZqWCbApPDIMK6V"
 425       "cPA1wrKgZqbWp218WBqI2v9pXV0O+jpzxq1+GeQV2UsbRwc=";
 426
 427     std::string message = "c2lnbmVkIGRhdGEK";
 428     std::string signature = "MC0CFQCL2pDA4S/zsHkDUCWOq7K6ebG14gIUHHoLsbeUd+BEqBXB6XjmcTncBRA=";
 429
 430     CertSvcString msgb64, sigb64, msg, sig;
 431
 432     int result = certsvc_string_new(vinstance, message.c_str(), message.size(), &msgb64);
 433     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in reading messsage.");
 434
 435     result = certsvc_string_new(vinstance, signature.c_str(), signature.size(), &sigb64);
 436     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in reading signature.");
 437
 438     CertSvcCertificate cert;
 439
 440     result = certsvc_certificate_new_from_memory(
 441         vinstance,
 442         (const unsigned char*)magda.c_str(),
 443         magda.size(),
 444         CERTSVC_FORM_DER_BASE64,
 445         &cert);
 446
 447     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in reading certificate.");
 448
 449     result = certsvc_base64_decode(msgb64, &msg);
 450     RUNNER_ASSERT_MSG(result == CERTSVC_TRUE, "Error in decoding base64.");
 451     result = certsvc_base64_decode(sigb64, &sig);
 452     RUNNER_ASSERT_MSG(result == CERTSVC_TRUE, "Error in decoding base64.");
 453
 454     int status;
 455     result = certsvc_message_verify(cert, msg, sig, "sha1", &status);
 456
 457     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in verify message.");
 458     RUNNER_ASSERT_MSG(status == CERTSVC_TRUE, "Error in verify message.");
 459 }
 460
 461 /*
 462  * author:      ---
 463  * test:        Verification of RSA SHA1.
 464  * description: Testing certificate RSA SH1.
 465  * expect:      Certificate RSA SH1 should be correct.
 466  */
 467 RUNNER_TEST(test09_message_verify_rsa_sha1)
 468 {
 469     std::string filip =
 470       "MIIC4zCCAkygAwIBAgIJAMdKgvadG/Z+MA0GCSqGSIb3DQEBBQUAMHIxCzAJBgNV"
 471       "BAYTAlBMMQwwCgYDVQQIEwNNYXoxEDAOBgNVBAoTB1NhbXN1bmcxDTALBgNVBAsT"
 472       "BFNQUkMxEDAOBgNVBAMTB1NhbXN1bmcxIjAgBgkqhkiG9w0BCQEWE3NhbXN1bmdA"
 473       "c2Ftc3VuZy5jb20wHhcNMTExMDA1MTIwMDUxWhcNMjExMDAyMTIwMDUxWjB4MQsw"
 474       "CQYDVQQGEwJQTDEMMAoGA1UECBMDTUFaMQwwCgYDVQQHEwNMZWcxDDAKBgNVBAoT"
 475       "A1NhbTENMAsGA1UECxMEU1BSQzEOMAwGA1UEAxMFRmlsaXAxIDAeBgkqhkiG9w0B"
 476       "CQEWEWZpbGlwQHNhbXN1bmcuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKB"
 477       "gQDS/sS0wXSCb34ojN8bWFd4Pl9eTLHh18UNGsPpLpp4itdfuc/OgyqaSoDwBzVh"
 478       "EWAVLCTxexUa4Ncva+41NbkW4RCsFzeGs0ktpu1+8Q+v0QEOGqVF2rQkgilzDF/o"
 479       "O56Fxw9vG1OA+qdQd3yOAV2EqLNBPrEYB9K5GFyffrakSQIDAQABo3sweTAJBgNV"
 480       "HRMEAjAAMCwGCWCGSAGG+EIBDQQfFh1PcGVuU1NMIEdlbmVyYXRlZCBDZXJ0aWZp"
 481       "Y2F0ZTAdBgNVHQ4EFgQUeyy3iV75KtOkpPFd6mnR9dFGZMwwHwYDVR0jBBgwFoAU"
 482       "ggh/2wAChuhTKqX6WK5nfxQ4yGAwDQYJKoZIhvcNAQEFBQADgYEADtv0CBrQ1QCM"
 483       "H9jKFjpSpq7zFKMXQeVtb/Zie823//woicg8kxnP5sS4dJWNXNb1iMLdhgV80g1y"
 484       "t3gTWPxTtFzprQyNiJHTmrbNWXLX1roRVGUE/I8Q4xexqpbNlJIW2Jjm/kqoKfnK"
 485       "xORG6HNPXZV29NY2fDRPPOIYoFQzrXI=";
 486
 487     std::string message = "Q3plZ28gdHUgc3p1a2Fzej8K";
 488     std::string signature =
 489       "xEIpVjEIUoDkYGtX2ih6Gbya0/gr7OMdvbBKmjqzfNh9GHqwrgjglByeC5sspUzPBUF4Vmg/hZqL"
 490       "gSsxXw9bKEa8c6mTQoNX51IC0ELPsoUMIJF1gGdFu0SzKptvU0+ksiiOM+70+s5t8s3z0G5PeA7O"
 491       "99oq8UlrX7GDlxaoTU4=";
 492
 493     CertSvcString msgb64, sigb64, msg, sig;
 494
 495     int result = certsvc_string_new(vinstance, message.c_str(), message.size(), &msgb64);
 496     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in reading messsage.");
 497
 498     result = certsvc_string_new(vinstance, signature.c_str(), signature.size(), &sigb64);
 499     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in reading signature.");
 500
 501     CertSvcCertificate cert;
 502
 503     result = certsvc_certificate_new_from_memory(
 504         vinstance,
 505         (const unsigned char*)filip.c_str(),
 506         filip.size(),
 507         CERTSVC_FORM_DER_BASE64,
 508         &cert);
 509
 510     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in reading certificate.");
 511
 512     result = certsvc_base64_decode(msgb64, &msg);
 513     RUNNER_ASSERT_MSG(result == CERTSVC_TRUE, "Error in decoding base64.");
 514
 515     result = certsvc_base64_decode(sigb64, &sig);
 516     RUNNER_ASSERT_MSG(result == CERTSVC_TRUE, "Error in decoding base64.");
 517
 518     int status;
 519     result = certsvc_message_verify(cert, msg, sig, "sha1", &status);
 520
 521     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in verify message.");
 522     RUNNER_ASSERT_MSG(status == CERTSVC_SUCCESS, "Error in verify message.");
 523
 524     message[0] = 'q';
 525
 526     result = certsvc_string_new(vinstance, message.c_str(), message.size(), &msgb64);
 527     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in reading messsage.");
 528
 529     result = certsvc_base64_decode(msgb64, &msg);
 530     RUNNER_ASSERT_MSG(result == CERTSVC_TRUE, "Error in decoding base64.");
 531
 532     result = certsvc_message_verify(cert, msg, sig, "sha1", &status);
 533
 534     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in verify message.");
 535     RUNNER_ASSERT_MSG(status == CERTSVC_INVALID_SIGNATURE, "Error in verify message.");
 536 }
 537
 538 /*
 539  * author:      ---
 540  * test:        Verification of RSA SHA1.
 541  * description: Testing certificate RSA SHA256.
 542  * expect:      Certificate RSA SH256 should be correct.
 543  */
 544 RUNNER_TEST(test10_message_verify_rsa_sha256)
 545 {
 546     std::string filip =
 547       "MIIC4zCCAkygAwIBAgIJAMdKgvadG/Z+MA0GCSqGSIb3DQEBBQUAMHIxCzAJBgNV"
 548       "BAYTAlBMMQwwCgYDVQQIEwNNYXoxEDAOBgNVBAoTB1NhbXN1bmcxDTALBgNVBAsT"
 549       "BFNQUkMxEDAOBgNVBAMTB1NhbXN1bmcxIjAgBgkqhkiG9w0BCQEWE3NhbXN1bmdA"
 550       "c2Ftc3VuZy5jb20wHhcNMTExMDA1MTIwMDUxWhcNMjExMDAyMTIwMDUxWjB4MQsw"
 551       "CQYDVQQGEwJQTDEMMAoGA1UECBMDTUFaMQwwCgYDVQQHEwNMZWcxDDAKBgNVBAoT"
 552       "A1NhbTENMAsGA1UECxMEU1BSQzEOMAwGA1UEAxMFRmlsaXAxIDAeBgkqhkiG9w0B"
 553       "CQEWEWZpbGlwQHNhbXN1bmcuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKB"
 554       "gQDS/sS0wXSCb34ojN8bWFd4Pl9eTLHh18UNGsPpLpp4itdfuc/OgyqaSoDwBzVh"
 555       "EWAVLCTxexUa4Ncva+41NbkW4RCsFzeGs0ktpu1+8Q+v0QEOGqVF2rQkgilzDF/o"
 556       "O56Fxw9vG1OA+qdQd3yOAV2EqLNBPrEYB9K5GFyffrakSQIDAQABo3sweTAJBgNV"
 557       "HRMEAjAAMCwGCWCGSAGG+EIBDQQfFh1PcGVuU1NMIEdlbmVyYXRlZCBDZXJ0aWZp"
 558       "Y2F0ZTAdBgNVHQ4EFgQUeyy3iV75KtOkpPFd6mnR9dFGZMwwHwYDVR0jBBgwFoAU"
 559       "ggh/2wAChuhTKqX6WK5nfxQ4yGAwDQYJKoZIhvcNAQEFBQADgYEADtv0CBrQ1QCM"
 560       "H9jKFjpSpq7zFKMXQeVtb/Zie823//woicg8kxnP5sS4dJWNXNb1iMLdhgV80g1y"
 561       "t3gTWPxTtFzprQyNiJHTmrbNWXLX1roRVGUE/I8Q4xexqpbNlJIW2Jjm/kqoKfnK"
 562       "xORG6HNPXZV29NY2fDRPPOIYoFQzrXI=";
 563
 564     std::string message = "Q3plZ28gdHUgc3p1a2Fzej8K";
 565     std::string signature =
 566       "a5nGT6wnbQ8MLwLkG965E4e1Rv983E+v3nolLvvjuAKnfgWYb+70Da+T9ggYDTjngq+EBgC30w1p"
 567       "EScrwye8ELefvRxDWy1+tWR4QRW/Nd4oN2U/pvozoabDSpe9Cvt0ECEOWKDqIYYnoWFjOiXg9VwD"
 568       "HVVkQXvsSYu6thX/Xsk=";
 569
 570     CertSvcString msgb64, sigb64, msg, sig;
 571
 572     int result = certsvc_string_new(vinstance, message.c_str(), message.size(), &msgb64);
 573     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in reading messsage.");
 574
 575     result = certsvc_string_new(vinstance, signature.c_str(), signature.size(), &sigb64);
 576     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in reading signature.");
 577
 578     CertSvcCertificate cert;
 579
 580     result = certsvc_certificate_new_from_memory(
 581         vinstance,
 582         (const unsigned char*)filip.c_str(),
 583         filip.size(),
 584         CERTSVC_FORM_DER_BASE64,
 585         &cert);
 586
 587     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in reading certificate.");
 588
 589     result = certsvc_base64_decode(msgb64, &msg);
 590     RUNNER_ASSERT_MSG(result == CERTSVC_TRUE, "Error in decoding base64.");
 591
 592     result = certsvc_base64_decode(sigb64, &sig);
 593     RUNNER_ASSERT_MSG(result == CERTSVC_TRUE, "Error in decoding base64.");
 594
 595     int status;
 596     result = certsvc_message_verify(cert, msg, sig, "sha256", &status);
 597
 598     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in verify message.");
 599     RUNNER_ASSERT_MSG(status == CERTSVC_SUCCESS, "Error in verify message.");
 600
 601     message[0] = 'q';
 602
 603     result = certsvc_string_new(vinstance, message.c_str(), message.size(), &msgb64);
 604     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in reading messsage.");
 605
 606     result = certsvc_base64_decode(msgb64, &msg);
 607     RUNNER_ASSERT_MSG(result == CERTSVC_TRUE, "Error in decoding base64.");
 608
 609     result = certsvc_message_verify(cert, msg, sig, "sha256", &status);
 610
 611     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in verify message.");
 612     RUNNER_ASSERT_MSG(status == CERTSVC_INVALID_SIGNATURE, "Error in verify message.");
 613 }
 614
 615 /*
 616  * author:      ---
 617  * test:        Certificate verification.
 618  * description: Verification of certificates.
 619  * expect:      Verification should return expected results.
 620  */
 621 RUNNER_TEST(test14_certificate_verify)
 622 {
 623     const int MAXC = 3;
 624     std::string cert[MAXC];
 625     cert[0] = // aia_signer
 626     "MIIDXTCCAsagAwIBAgIBAjANBgkqhkiG9w0BAQUFADB6MQswCQYDVQQGEwJLUjEO"
 627     "MAwGA1UECAwFU2VvdWwxEDAOBgNVBAoMB1NhbXN1bmcxEzARBgNVBAsMClRpemVu"
 628     "IFRlc3QxFzAVBgNVBAMMDlRlc3QgU2Vjb25kIENBMRswGQYJKoZIhvcNAQkBFgx0"
 629     "dEBnbWFpbC5jb20wHhcNMTQwNjE4MDgxMTA0WhcNMTUwNjE4MDgxMTA0WjB7MQsw"
 630     "CQYDVQQGEwJLUjEOMAwGA1UECAwFU2VvdWwxEDAOBgNVBAoMB1NhbXN1bmcxFzAV"
 631     "BgNVBAsMDlRpemVuIFRlc3QgQUlBMRQwEgYDVQQDDAtUZXN0IFNpZ25lcjEbMBkG"
 632     "CSqGSIb3DQEJARYMdHRAZ21haWwuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCB"
 633     "iQKBgQCwgKw+/71jWXnx4bLLZrTPmE+NrDfHSfZx8yTGYeewMzP6ZlXM8WduxNiq"
 634     "pqm7G2XN182GEXsdoxwa09HtMVGqSGA/BCamD1Z6liHOEb4UTB3ROJ1lZDDkyJ9a"
 635     "gZOfoZst/Aj8+bwV3x3ie+p4a2w/8eSsalrfef2gX6khaSsJOwIDAQABo4HxMIHu"
 636     "MAkGA1UdEwQCMAAwLAYJYIZIAYb4QgENBB8WHU9wZW5TU0wgR2VuZXJhdGVkIENl"
 637     "cnRpZmljYXRlMB0GA1UdDgQWBBRL0nKiNUjzh1/LPvZoqLvnVfOZqjAfBgNVHSME"
 638     "GDAWgBSpSfNbE0V2NHn/V5f660v2cWwYgDBzBggrBgEFBQcBAQRnMGUwIQYIKwYB"
 639     "BQUHMAGGFWh0dHA6Ly8xMjcuMC4wLjE6ODg4ODBABggrBgEFBQcwAoY0aHR0cDov"
 640     "L1NWUlNlY3VyZS1HMy1haWEudmVyaXNpZ24uY29tL1NWUlNlY3VyZUczLmNlcjAN"
 641     "BgkqhkiG9w0BAQUFAAOBgQABP+yru9/2auZ4ekjV03WRg5Vq/rqmOHDruMNVbZ4H"
 642     "4PBLRLSpC//OGahgEgUKe89BcB10lUi55D5YME3Do89I+hFugv0BPGaA201iLOhL"
 643     "/0u0aVm1yJxNt1YjW2fMKqnCHgjoHzh0wQC1pIb5vxJrYCn3Pbhml7W6JPDDJHfm"
 644     "XQ==";
 645
 646     cert[1] = // second_ca
 647     "MIIDLzCCApigAwIBAgIBATANBgkqhkiG9w0BAQUFADB4MQswCQYDVQQGEwJLUjEO"
 648     "MAwGA1UECAwFU2VvdWwxEDAOBgNVBAoMB1NhbXN1bmcxEzARBgNVBAsMClRpemVu"
 649     "IFRlc3QxFTATBgNVBAMMDFRlc3QgUm9vdCBDQTEbMBkGCSqGSIb3DQEJARYMdHRA"
 650     "Z21haWwuY29tMB4XDTE0MDYxODA4MTA1OVoXDTE1MDYxODA4MTA1OVowejELMAkG"
 651     "A1UEBhMCS1IxDjAMBgNVBAgMBVNlb3VsMRAwDgYDVQQKDAdTYW1zdW5nMRMwEQYD"
 652     "VQQLDApUaXplbiBUZXN0MRcwFQYDVQQDDA5UZXN0IFNlY29uZCBDQTEbMBkGCSqG"
 653     "SIb3DQEJARYMdHRAZ21haWwuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKB"
 654     "gQDLJrMAF/JzxIIrQzQ/3FGt7cGAUEYaEFSo+hcDKYRXaZC33/kkVANYFh+log9e"
 655     "MJUUlt0TBOg79tOnS/5MBwWaVLEOLalv0Uj2FfjEMpGd/xEF6Vv34mSTcWadMHyD"
 656     "wYwDZVwdFkrvOkA6WwgwS8XSrpbH/nkKUkKpk+YYljKEzQIDAQABo4HGMIHDMB0G"
 657     "A1UdDgQWBBSpSfNbE0V2NHn/V5f660v2cWwYgDAfBgNVHSMEGDAWgBRkHk9Lnhgv"
 658     "vOIwxHOma54FGt8SCDAMBgNVHRMEBTADAQH/MHMGCCsGAQUFBwEBBGcwZTAhBggr"
 659     "BgEFBQcwAYYVaHR0cDovLzEyNy4wLjAuMTo4ODg4MEAGCCsGAQUFBzAChjRodHRw"
 660     "Oi8vU1ZSU2VjdXJlLUczLWFpYS52ZXJpc2lnbi5jb20vU1ZSU2VjdXJlRzMuY2Vy"
 661     "MA0GCSqGSIb3DQEBBQUAA4GBAFonDQzs/Ts1sEDW3f5EmuKVZlpH9sLstSLJxZK8"
 662     "+v88Jbz451/Lf8hxvnMv3MwExXr9qPKPlvKRfj+bbLB5KTEcZ5zhDpJ7SDYesdUd"
 663     "RKOMSN0JIRL3JOCdYHOnJk6o+45vZ/TNv0lsiK90vxH2jo2EXnNG+jeyBGwp+3H6"
 664     "RWHw";
 665
 666     cert[2] = // root_ca
 667     "MIIDLTCCApagAwIBAgIBADANBgkqhkiG9w0BAQUFADB4MQswCQYDVQQGEwJLUjEO"
 668     "MAwGA1UECAwFU2VvdWwxEDAOBgNVBAoMB1NhbXN1bmcxEzARBgNVBAsMClRpemVu"
 669     "IFRlc3QxFTATBgNVBAMMDFRlc3QgUm9vdCBDQTEbMBkGCSqGSIb3DQEJARYMdHRA"
 670     "Z21haWwuY29tMB4XDTE0MDYxODA4MTA1MVoXDTE1MDYxODA4MTA1MVoweDELMAkG"
 671     "A1UEBhMCS1IxDjAMBgNVBAgMBVNlb3VsMRAwDgYDVQQKDAdTYW1zdW5nMRMwEQYD"
 672     "VQQLDApUaXplbiBUZXN0MRUwEwYDVQQDDAxUZXN0IFJvb3QgQ0ExGzAZBgkqhkiG"
 673     "9w0BCQEWDHR0QGdtYWlsLmNvbTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA"
 674     "o6ZegsQ9hScM1yD7ejv44xUTJDjTlcGweHh76Im22x6yAljM2+dKdj3EIVGt0BA3"
 675     "6qdZFl8WOxzQGcAzQY7GFOXQVog4UjqHMxmWwAx5jQyBzIieAj4HZ2lquPBiyiIe"
 676     "HAo6sCSWsxnh7PqvWaAypPZVEqOJ3ga5rXyDCcjzQ8ECAwEAAaOBxjCBwzAdBgNV"
 677     "HQ4EFgQUZB5PS54YL7ziMMRzpmueBRrfEggwHwYDVR0jBBgwFoAUZB5PS54YL7zi"
 678     "MMRzpmueBRrfEggwDAYDVR0TBAUwAwEB/zBzBggrBgEFBQcBAQRnMGUwIQYIKwYB"
 679     "BQUHMAGGFWh0dHA6Ly8xMjcuMC4wLjE6ODg4ODBABggrBgEFBQcwAoY0aHR0cDov"
 680     "L1NWUlNlY3VyZS1HMy1haWEudmVyaXNpZ24uY29tL1NWUlNlY3VyZUczLmNlcjAN"
 681     "BgkqhkiG9w0BAQUFAAOBgQAyRJXTZcwRCkRNGZQCO8txHvrmgv8vQwnZZF6SwyY/"
 682     "Bry0fmlehtN52NLjjPEG6u9YFYfzSkjQlVR0qfQ2mNs3d6AKFlOdZOT6cuEIZuKe"
 683     "pDb2Tx5JJbIN6N3fE/lVSW88K9aSCF2n15gYTSVmD0juHuLAoWnIicaa+Sbe2Tsj"
 684     "AQ==";
 685
 686     CertSvcCertificate certificate[MAXC];
 687
 688     int result, status;
 689
 690     for (int i=0; i<MAXC; ++i) {
 691         LogDebug("Reading certificate: " << i);
 692         int result = certsvc_certificate_new_from_memory(
 693             vinstance,
 694             (const unsigned char*)cert[i].c_str(),
 695             cert[i].size(),
 696             CERTSVC_FORM_DER_BASE64,
 697             &certificate[i]);
 698         RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error reading certificate");
 699     }
 700
 701     result = certsvc_certificate_verify(certificate[0], &certificate[1], MAXC-1, NULL, 0, &status);
 702     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in certificate verification function.");
 703     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == status, "Error in certificate verification process.");
 704
 705     result = certsvc_certificate_verify(certificate[0], certificate, MAXC-1, NULL, 0, &status);
 706     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in certificate verification function.");
 707     RUNNER_ASSERT_MSG(CERTSVC_FAIL == status, "Error in certificate verification process.");
 708
 709     result = certsvc_certificate_verify(certificate[0], certificate, 1, certificate, MAXC, &status);
 710     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in certificate verification function.");
 711     RUNNER_ASSERT_MSG(CERTSVC_FAIL == status, "Error in certificate verification process.");
 712
 713     result = certsvc_certificate_verify(certificate[0], &certificate[2], 1, certificate, MAXC, &status);
 714     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in certificate verification function.");
 715     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == status, "Error in certificate verification process.");
 716
 717
 718     // certsvc_certificate_verify_with_caflag
 719     result = certsvc_certificate_verify_with_caflag(certificate[0], certificate, MAXC, NULL, 0, &status);
 720     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in certificate verification function.");
 721     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == status, "Error in certificate verification process.");
 722
 723     result = certsvc_certificate_verify_with_caflag(certificate[0], certificate, MAXC-1, NULL, 0, &status);
 724     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in certificate verification function.");
 725     RUNNER_ASSERT_MSG(CERTSVC_FAIL == status, "Error in certificate verification process.");
 726
 727     result = certsvc_certificate_verify_with_caflag(certificate[0], certificate, 1, certificate, MAXC, &status);
 728     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in certificate verification function.");
 729     RUNNER_ASSERT_MSG(CERTSVC_FAIL == status, "Error in certificate verification process.");
 730
 731     result = certsvc_certificate_verify_with_caflag(certificate[0], &certificate[2], 1, certificate, MAXC, &status);
 732     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in certificate verification function.");
 733     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == status, "Error in certificate verification process.");
 734 }
 735
 736 /*
 737  * author:      ---
 738  * test:        Testing certificate primitives.
 739  * description: Certificate structure is tested.
 740  * expect:      Certificate should contain cexpected informations.
 741  */
 742 RUNNER_TEST(test15_cprimitives)
 743 {
 744     const int MAXB = 1024;
 745     const std::string cert =
 746       "MIICPDCCAaUCEHC65B0Q2Sk0tjjKewPMur8wDQYJKoZIhvcNAQECBQAwXzELMAkG"
 747       "A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFz"
 748       "cyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTk2"
 749       "MDEyOTAwMDAwMFoXDTI4MDgwMTIzNTk1OVowXzELMAkGA1UEBhMCVVMxFzAVBgNV"
 750       "BAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFzcyAzIFB1YmxpYyBQcmlt"
 751       "YXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGfMA0GCSqGSIb3DQEBAQUAA4GN"
 752       "ADCBiQKBgQDJXFme8huKARS0EN8EQNvjV69qRUCPhAwL0TPZ2RHP7gJYHyX3KqhE"
 753       "BarsAx94f56TuZoAqiN91qyFomNFx3InzPRMxnVx0jnvT0Lwdd8KkMaOIG+YD/is"
 754       "I19wKTakyYbnsZogy1Olhec9vn2a/iRFM9x2Fe0PonFkTGUugWhFpwIDAQABMA0G"
 755       "CSqGSIb3DQEBAgUAA4GBALtMEivPLCYATxQT3ab7/AoRhIzzKBxnki98tsX63/Do"
 756       "lbwdj2wsqFHMc9ikwFPwTtYmwHYBV4GSXiHx0bH/59AhWM1pF+NEHJwZRDmJXNyc"
 757       "AA9WjQKZ7aKQRUzkuxCkPfAyAw7xzvjoyVGM5mKf5p/AfbdynMk2OmufTqj/ZA1k";
 758
 759     CertSvcCertificate certificate;
 760
 761     int result;
 762
 763     result = certsvc_certificate_new_from_memory(
 764         vinstance,
 765         (const unsigned char*)cert.c_str(),
 766         cert.size(),
 767         CERTSVC_FORM_DER_BASE64,
 768         &certificate);
 769
 770     X509 *x509 = NULL;
 771     result = certsvc_certificate_dup_x509(certificate, &x509);
 772
 773     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in certsvc_certificate_dup_x509.");
 774     RUNNER_ASSERT_MSG(x509 != NULL, "Error in certsvc_certificate_dup_x509.");
 775
 776     X509_NAME *name = X509_get_subject_name(x509);
 777     char buffer[MAXB];
 778     X509_NAME_oneline(name, buffer, MAXB);
 779     std::string expected = "/C=US/O=VeriSign, Inc./OU=Class 3 Public Primary Certification Authority";
 780
 781     LogDebug("NAME: " << buffer);
 782
 783     RUNNER_ASSERT_MSG(expected == buffer, "Content does not match");
 784
 785     certsvc_certificate_free_x509(x509);
 786 }
 787
 788
 789 /*
 790  * author:      ---
 791  * test:        Certificate verification.
 792  * description: Verification of certificates.
 793  * expect:      Verification should return expected results.
 794  */
 795 RUNNER_TEST(test16_certificate_verify_with_caflag_selfsign_root)
 796 {
 797     const int MAXC = 2;
 798     std::string cert[MAXC];
 799     cert[0] = // v1_signer
 800       "MIICdzCCAeACAQcwDQYJKoZIhvcNAQEFBQAwgYIxCzAJBgNVBAYTAktSMQ4wDAYD"
 801       "VQQIDAVTZW91bDEQMA4GA1UECgwHU2Ftc3VuZzETMBEGA1UECwwKVGl6ZW4gVGVz"
 802       "dDEfMB0GA1UEAwwWVGVzdCBSb290IENBIFZlcnNpb24gMTEbMBkGCSqGSIb3DQEJ"
 803       "ARYMdHRAZ21haWwuY29tMB4XDTE0MDYxNDA4MTI1MFoXDTE1MDYxNDA4MTI1MFow"
 804       "gYQxCzAJBgNVBAYTAktSMQ4wDAYDVQQIDAVTZW91bDEQMA4GA1UECgwHU2Ftc3Vu"
 805       "ZzETMBEGA1UECwwKVGl6ZW4gVGVzdDEhMB8GA1UEAwwYVGVzdCBTZWNvbmQgQ0Eg"
 806       "VmVyc2lvbiAxMRswGQYJKoZIhvcNAQkBFgx0dEBnbWFpbC5jb20wgZ8wDQYJKoZI"
 807       "hvcNAQEBBQADgY0AMIGJAoGBAKOqFNxvO2jYcq5kqVehHH5k1D1dYwhBnH/SReWE"
 808       "OTSbH+3lbaKhJQHPHjsndENUxPInF6r0prO3TqoMB6774Pmc+znoVfLsHvWorhyr"
 809       "8iQNyaSgVWt0+8L0FU8iReqr5BR6YcZpnVRCV9dAIcf6FIVGUGZhTs/NvZDzIc4T"
 810       "9RrLAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAGDDvWhdMFg4GtDdytrK/GJ9TxX5F"
 811       "9iA/8qCl0+JU1U7jUVIcX77AxeZGBtq02X+DtjEWqnepS1iYO2TUHZBKRRCB2+wF"
 812       "ZsQ5XWngLSco+UvqUzMpWIQqslDXixWSR+Bef2S7iND3u8HJLjTncMcuJNpoXsFK"
 813       "bUiLqMVGQCkGZMo=";
 814
 815     cert[1] = // v1_root
 816       "MIICdTCCAd4CAQYwDQYJKoZIhvcNAQEFBQAwgYIxCzAJBgNVBAYTAktSMQ4wDAYD"
 817       "VQQIDAVTZW91bDEQMA4GA1UECgwHU2Ftc3VuZzETMBEGA1UECwwKVGl6ZW4gVGVz"
 818       "dDEfMB0GA1UEAwwWVGVzdCBSb290IENBIFZlcnNpb24gMTEbMBkGCSqGSIb3DQEJ"
 819       "ARYMdHRAZ21haWwuY29tMB4XDTE0MDYxNDA4MTIzNVoXDTE1MDYxNDA4MTIzNVow"
 820       "gYIxCzAJBgNVBAYTAktSMQ4wDAYDVQQIDAVTZW91bDEQMA4GA1UECgwHU2Ftc3Vu"
 821       "ZzETMBEGA1UECwwKVGl6ZW4gVGVzdDEfMB0GA1UEAwwWVGVzdCBSb290IENBIFZl"
 822       "cnNpb24gMTEbMBkGCSqGSIb3DQEJARYMdHRAZ21haWwuY29tMIGfMA0GCSqGSIb3"
 823       "DQEBAQUAA4GNADCBiQKBgQDtxGjhpaUK6xa4+sjMQfkKRAtjFkjZasVIt7uKUy/g"
 824       "GcC5i5aoorfyX/NBQLAVoIHMogHLgitehKL5l13tLR7DSETrG9V3Yx9bkWRcjyqH"
 825       "1TkD+NDOmhTtVuqIh4hrGKITlZK35hOh0IUEfYNNL8uq/11fVPpR3Yx97PT/j4w1"
 826       "uwIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAOHjfa7nbPKhqR0mGfsscPQZZAZzKq9y"
 827       "ttdjTaNbnybzcJzcN3uwOdYKMf26Dn968nAPkukWe8j6GyMJ1C9LMAWqMn5hl0rI"
 828       "x6mUBfKZrl33BKH4KTYOrt0vnHdrCM2TwMkwMZ5ja5bBnbNrfF4e0HIAMor4rnVP"
 829       "WDSlESMMmtTm";
 830
 831     CertSvcCertificate certificate[MAXC];
 832
 833     int result, status;
 834
 835     for (int i=0; i<MAXC; ++i) {
 836         LogDebug("Reading certificate: " << i);
 837         int result = certsvc_certificate_new_from_memory(
 838             vinstance,
 839             (const unsigned char*)cert[i].c_str(),
 840             cert[i].size(),
 841             CERTSVC_FORM_DER_BASE64,
 842             &certificate[i]);
 843         RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error reading certificate");
 844     }
 845
 846     result = certsvc_certificate_verify(certificate[0], certificate, MAXC, NULL, 0, &status);
 847     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in certificate verification function.");
 848     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == status, "Error in certificate verification process.");
 849
 850     result = certsvc_certificate_verify_with_caflag(certificate[0], certificate, MAXC, NULL, 0, &status);
 851     RUNNER_ASSERT_MSG(CERTSVC_SUCCESS == result, "Error in certificate verification function.");
 852     RUNNER_ASSERT_MSG(CERTSVC_FAIL == status, "Error in certificate verification process.");
 853 }