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