[thirdparty/openssl.git] / test / ct_test.c

/*
 * Tests the Certificate Transparency public API.
 *
 * Author:      Rob Percival (robpercival@google.com)
 *
 * ====================================================================
 * Copyright (c) 2016 The OpenSSL Project.    All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *        notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *        notice, this list of conditions and the following disclaimer in
 *        the documentation and/or other materials provided with the
 *        distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *        software must display the following acknowledgment:
 *        "This product includes software developed by the OpenSSL Project
 *        for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *        endorse or promote products derived from this software without
 *        prior written permission. For written permission, please contact
 *        licensing@OpenSSL.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *        nor may "OpenSSL" appear in their names without prior written
 *        permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *        acknowledgment:
 *        "This product includes software developed by the OpenSSL Project
 *        for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.    IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 */

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <openssl/ct.h>
#include <openssl/err.h>
#include <openssl/pem.h>
#include <openssl/x509.h>
#include <openssl/x509v3.h>
#include "testutil.h"

#ifndef OPENSSL_NO_CT

/* Used when declaring buffers to read text files into */
#define CT_TEST_MAX_FILE_SIZE 8096

static char *certs_dir = NULL;
static char *ct_dir = NULL;

typedef struct ct_test_fixture {
    const char *test_case_name;
    /* The CT log store to use during tests */
    CTLOG_STORE* ctlog_store;
    /* Set the following to test handling of SCTs in X509 certificates */
    const char *certs_dir;
    char *certificate_file;
    char *issuer_file;
    int expected_sct_count;
    /* Set the following to test handling of SCTs in TLS format */
    const unsigned char *tls_sct;
    size_t tls_sct_len;
    SCT *sct;
    /*
     * A file to load the expected SCT text from.
     * This text will be compared to the actual text output during the test.
     * A maximum of |CT_TEST_MAX_FILE_SIZE| bytes will be read of this file.
     */
    const char *sct_dir;
    const char *sct_text_file;
    /* Whether to test the validity of the SCT(s) */
    int test_validity;

} CT_TEST_FIXTURE;

static CT_TEST_FIXTURE set_up(const char *const test_case_name)
{
    CT_TEST_FIXTURE fixture;
    int setup_ok = 1;
    CTLOG_STORE *ctlog_store = CTLOG_STORE_new();

    if (ctlog_store == NULL) {
        setup_ok = 0;
        fprintf(stderr, "Failed to create a new CT log store\n");
        goto end;
    }

    if (CTLOG_STORE_load_default_file(ctlog_store) != 1) {
        setup_ok = 0;
        fprintf(stderr, "Failed to load CT log list\n");
        goto end;
    }

    memset(&fixture, 0, sizeof(fixture));
    fixture.test_case_name = test_case_name;
    fixture.ctlog_store = ctlog_store;

end:
    if (!setup_ok) {
        exit(EXIT_FAILURE);
    }
    return fixture;
}

static void tear_down(CT_TEST_FIXTURE fixture)
{
    CTLOG_STORE_free(fixture.ctlog_store);
    SCT_free(fixture.sct);
    ERR_print_errors_fp(stderr);
}

static char *mk_file_path(const char *dir, const char *file)
{
    char *full_file = NULL;
    size_t full_file_l = 0;
    const char *sep = "";
#ifndef OPENSSL_SYS_VMS
    sep = "/";
#endif

    full_file_l = strlen(dir) + strlen(sep) + strlen(file) + 1;
    full_file = OPENSSL_zalloc(full_file_l);
    if (full_file != NULL) {
        OPENSSL_strlcpy(full_file, dir, full_file_l);
        OPENSSL_strlcat(full_file, sep, full_file_l);
        OPENSSL_strlcat(full_file, file, full_file_l);
    }

    return full_file;
}

static X509 *load_pem_cert(const char *dir, const char *file)
{
    X509 *cert = NULL;
    char *file_path = mk_file_path(dir, file);

    if (file_path != NULL) {
        BIO *cert_io = BIO_new_file(file_path, "r");
        OPENSSL_free(file_path);

        if (cert_io != NULL)
            cert = PEM_read_bio_X509(cert_io, NULL, NULL, NULL);

        BIO_free(cert_io);
    }
    return cert;
}

static int read_text_file(const char *dir, const char *file,
                          char *buffer, int buffer_length)
{
    int result = -1;
    char *file_path = mk_file_path(dir, file);

    if (file_path != NULL) {
        BIO *file_io = BIO_new_file(file_path, "r");
        OPENSSL_free(file_path);

        if (file_io != NULL) {
            result = BIO_read(file_io, buffer, buffer_length);
            BIO_free(file_io);
        }
    }

    return result;
}

static int compare_sct_printout(SCT *sct,
    const char *expected_output)
{
    BIO *text_buffer = NULL;
    char *actual_output = NULL;
    int result = 1;

    text_buffer = BIO_new(BIO_s_mem());
    if (text_buffer == NULL) {
        fprintf(stderr, "Unable to allocate buffer\n");
        goto end;
    }

    SCT_print(sct, text_buffer, 0, NULL);

    /* Append null terminator because we're about to use the buffer contents
    * as a string. */
    if (BIO_write(text_buffer, "\0", 1) != 1) {
        fprintf(stderr, "Failed to append null terminator to SCT text\n");
        goto end;
    }

    BIO_get_mem_data(text_buffer, &actual_output);
    result = strcmp(actual_output, expected_output);

    if (result != 0) {
        fprintf(stderr,
            "Expected SCT printout:\n%s\nActual SCT printout:\n%s\n",
            expected_output, actual_output);
    }

end:
    BIO_free(text_buffer);
    return result;
}

static int compare_extension_printout(X509_EXTENSION *extension,
                                      const char *expected_output)
{
    BIO *text_buffer = NULL;
    char *actual_output = NULL;
    int result = 1;

    text_buffer = BIO_new(BIO_s_mem());
    if (text_buffer == NULL) {
        fprintf(stderr, "Unable to allocate buffer\n");
        goto end;
    }

    if (!X509V3_EXT_print(text_buffer, extension, X509V3_EXT_DEFAULT, 0)) {
        fprintf(stderr, "Failed to print extension\n");
        goto end;
    }

    /* Append null terminator because we're about to use the buffer contents
     * as a string. */
    if (BIO_write(text_buffer, "\0", 1) != 1) {
        fprintf(stderr, "Failed to append null terminator to extension text\n");
        goto end;
    }

    BIO_get_mem_data(text_buffer, &actual_output);
    result = strcmp(actual_output, expected_output);

    if (result != 0) {
        fprintf(stderr,
                "Expected SCT printout:\n%s\nActual SCT printout:\n%s\n",
                expected_output, actual_output);
    }

end:
    BIO_free(text_buffer);
    return result;
}

static int execute_cert_test(CT_TEST_FIXTURE fixture)
{
    int test_failed = 0;
    X509 *cert = NULL, *issuer = NULL;
    STACK_OF(SCT) *scts = NULL;
    SCT *sct = NULL;
    char expected_sct_text[CT_TEST_MAX_FILE_SIZE];
    int sct_text_len = 0;
    unsigned char *tls_sct = NULL;
    size_t tls_sct_len = 0;
    CT_POLICY_EVAL_CTX *ct_policy_ctx = CT_POLICY_EVAL_CTX_new();

    if (fixture.sct_text_file != NULL) {
        sct_text_len = read_text_file(fixture.sct_dir, fixture.sct_text_file,
                                      expected_sct_text,
                                      CT_TEST_MAX_FILE_SIZE - 1);

        if (sct_text_len < 0) {
            test_failed = 1;
            fprintf(stderr, "Test data file not found: %s\n",
                fixture.sct_text_file);
            goto end;
        }

        expected_sct_text[sct_text_len] = '\0';
    }

    CT_POLICY_EVAL_CTX_set0_log_store(ct_policy_ctx, fixture.ctlog_store);

    if (fixture.certificate_file != NULL) {
        int sct_extension_index;
        X509_EXTENSION *sct_extension = NULL;
        cert = load_pem_cert(fixture.certs_dir, fixture.certificate_file);

        if (cert == NULL) {
            test_failed = 1;
            fprintf(stderr, "Unable to load certificate: %s\n",
                fixture.certificate_file);
            goto end;
        }

        CT_POLICY_EVAL_CTX_set0_cert(ct_policy_ctx, cert);

        if (fixture.issuer_file != NULL) {
            issuer = load_pem_cert(fixture.certs_dir, fixture.issuer_file);

            if (issuer == NULL) {
                test_failed = 1;
                fprintf(stderr, "Unable to load issuer certificate: %s\n",
                        fixture.issuer_file);
                goto end;
            }

            CT_POLICY_EVAL_CTX_set0_issuer(ct_policy_ctx, issuer);
        }

        sct_extension_index =
                X509_get_ext_by_NID(cert, NID_ct_precert_scts, -1);
        sct_extension = X509_get_ext(cert, sct_extension_index);
        if (fixture.expected_sct_count > 0) {
            if (sct_extension == NULL) {
                test_failed = 1;
                fprintf(stderr, "SCT extension not found in: %s\n",
                    fixture.certificate_file);
                goto end;
            }

            if (fixture.sct_text_file) {
                test_failed = compare_extension_printout(sct_extension,
                                                    expected_sct_text);
                if (test_failed != 0)
                    goto end;
            }

            if (fixture.test_validity) {
                int are_scts_validated = 0;
                int i;

                scts = X509V3_EXT_d2i(sct_extension);
                for (i = 0; i < sk_SCT_num(scts); ++i) {
                    SCT *sct_i = sk_SCT_value(scts, i);

                    if (!SCT_set_source(sct_i, SCT_SOURCE_X509V3_EXTENSION)) {
                        fprintf(stderr,
                                "Error setting SCT source to X509v3 extension\n");
                        test_failed = 1;
                        goto end;
                    }
                }

                are_scts_validated = SCT_LIST_validate(scts, ct_policy_ctx);
                if (are_scts_validated < 0) {
                    fprintf(stderr, "Error verifying SCTs\n");
                    test_failed = 1;
                } else if (!are_scts_validated) {
                    int invalid_sct_count = 0;
                    int valid_sct_count = 0;

                    for (i = 0; i < sk_SCT_num(scts); ++i) {
                        SCT *sct_i = sk_SCT_value(scts, i);
                        switch (SCT_get_validation_status(sct_i)) {
                        case SCT_VALIDATION_STATUS_VALID:
                            ++valid_sct_count;
                            break;
                        case SCT_VALIDATION_STATUS_INVALID:
                            ++invalid_sct_count;
                            break;
                        default:
                            /* Ignore other validation statuses. */
                            break;
                        }
                    }

                    if (valid_sct_count != fixture.expected_sct_count) {
                        int unverified_sct_count = sk_SCT_num(scts) -
                                invalid_sct_count - valid_sct_count;

                        fprintf(stderr,
                                "%d SCTs failed verification\n"
                                "%d SCTs passed verification (%d expected)\n"
                                "%d SCTs were unverified\n",
                                invalid_sct_count,
                                valid_sct_count,
                                fixture.expected_sct_count,
                                unverified_sct_count);
                    }
                    test_failed = 1;
                }

                if (test_failed != 0)
                    goto end;
            }
        } else if (sct_extension != NULL) {
            test_failed = 1;
            fprintf(stderr,
                    "Expected no SCTs, but found SCT extension in: %s\n",
                    fixture.certificate_file);
            goto end;
        }
    }

    if (fixture.tls_sct != NULL) {
        const unsigned char *p = fixture.tls_sct;
        if (o2i_SCT(&sct, &p, fixture.tls_sct_len) == NULL) {
            test_failed = 1;
            fprintf(stderr, "Failed to decode SCT from TLS format\n");
            goto end;
        }

        if (fixture.sct_text_file) {
            test_failed = compare_sct_printout(sct, expected_sct_text);
            if (test_failed != 0)
                goto end;
        }

        tls_sct_len = i2o_SCT(sct, &tls_sct);
        if (tls_sct_len != fixture.tls_sct_len ||
            memcmp(fixture.tls_sct, tls_sct, tls_sct_len) != 0) {
            test_failed = 1;
            fprintf(stderr, "Failed to encode SCT into TLS format correctly\n");
            goto end;
        }

        if (fixture.test_validity && cert != NULL) {
            int is_sct_validated = SCT_validate(sct, ct_policy_ctx);
            if (is_sct_validated < 0) {
                test_failed = 1;
                fprintf(stderr, "Error validating SCT\n");
                goto end;
            } else if (!is_sct_validated) {
                test_failed = 1;
                fprintf(stderr, "SCT failed verification\n");
                goto end;
            }
        }
    }

end:
    X509_free(cert);
    X509_free(issuer);
    SCT_LIST_free(scts);
    SCT_free(sct);
    CT_POLICY_EVAL_CTX_free(ct_policy_ctx);
    OPENSSL_free(tls_sct);
    return test_failed;
}

#define SETUP_CT_TEST_FIXTURE() SETUP_TEST_FIXTURE(CT_TEST_FIXTURE, set_up)
#define EXECUTE_CT_TEST() EXECUTE_TEST(execute_cert_test, tear_down)

static int test_no_scts_in_certificate()
{
    SETUP_CT_TEST_FIXTURE();
    fixture.certs_dir = certs_dir;
    fixture.certificate_file = "leaf.pem";
    fixture.issuer_file = "subinterCA.pem";
    fixture.expected_sct_count = 0;
    EXECUTE_CT_TEST();
}

static int test_one_sct_in_certificate()
{
    SETUP_CT_TEST_FIXTURE();
    fixture.certs_dir = certs_dir;
    fixture.certificate_file = "embeddedSCTs1.pem";
    fixture.issuer_file = "embeddedSCTs1_issuer.pem";
    fixture.expected_sct_count = 1;
    fixture.sct_dir = certs_dir;
    fixture.sct_text_file = "embeddedSCTs1.sct";
    EXECUTE_CT_TEST();
}

static int test_multiple_scts_in_certificate()
{
    SETUP_CT_TEST_FIXTURE();
    fixture.certs_dir = certs_dir;
    fixture.certificate_file = "embeddedSCTs3.pem";
    fixture.issuer_file = "embeddedSCTs3_issuer.pem";
    fixture.expected_sct_count = 3;
    fixture.sct_dir = certs_dir;
    fixture.sct_text_file = "embeddedSCTs3.sct";
    EXECUTE_CT_TEST();
}

static int test_verify_one_sct()
{
    SETUP_CT_TEST_FIXTURE();
    fixture.certs_dir = certs_dir;
    fixture.certificate_file = "embeddedSCTs1.pem";
    fixture.issuer_file = "embeddedSCTs1_issuer.pem";
    fixture.expected_sct_count = 1;
    fixture.test_validity = 1;
    EXECUTE_CT_TEST();
}

static int test_verify_multiple_scts()
{
    SETUP_CT_TEST_FIXTURE();
    fixture.certs_dir = certs_dir;
    fixture.certificate_file = "embeddedSCTs3.pem";
    fixture.issuer_file = "embeddedSCTs3_issuer.pem";
    fixture.expected_sct_count = 3;
    fixture.test_validity = 1;
    EXECUTE_CT_TEST();
}

static int test_decode_tls_sct()
{
    const unsigned char tls_sct[] = "\x00" /* version */
        /* log ID */
        "\xDF\x1C\x2E\xC1\x15\x00\x94\x52\x47\xA9\x61\x68\x32\x5D\xDC\x5C\x79"
        "\x59\xE8\xF7\xC6\xD3\x88\xFC\x00\x2E\x0B\xBD\x3F\x74\xD7\x64"
        "\x00\x00\x01\x3D\xDB\x27\xDF\x93" /* timestamp */
        "\x00\x00" /* extensions length */
        "" /* extensions */
        "\x04\x03" /* hash and signature algorithms */
        "\x00\x47" /* signature length */
        /* signature */
        "\x30\x45\x02\x20\x48\x2F\x67\x51\xAF\x35\xDB\xA6\x54\x36\xBE\x1F\xD6"
        "\x64\x0F\x3D\xBF\x9A\x41\x42\x94\x95\x92\x45\x30\x28\x8F\xA3\xE5\xE2"
        "\x3E\x06\x02\x21\x00\xE4\xED\xC0\xDB\x3A\xC5\x72\xB1\xE2\xF5\xE8\xAB"
        "\x6A\x68\x06\x53\x98\x7D\xCF\x41\x02\x7D\xFE\xFF\xA1\x05\x51\x9D\x89"
        "\xED\xBF\x08";

    SETUP_CT_TEST_FIXTURE();
    fixture.tls_sct = tls_sct;
    fixture.tls_sct_len = 118;
    fixture.sct_dir = ct_dir;
    fixture.sct_text_file = "tls1.sct";
    EXECUTE_CT_TEST();
}

static int test_encode_tls_sct()
{
    const unsigned char log_id[] = "\xDF\x1C\x2E\xC1\x15\x00\x94\x52\x47\xA9"
            "\x61\x68\x32\x5D\xDC\x5C\x79\x59\xE8\xF7\xC6\xD3\x88\xFC\x00\x2E"
            "\x0B\xBD\x3F\x74\xD7\x64";

    const unsigned char signature[] = "\x45\x02\x20\x48\x2F\x67\x51\xAF\x35"
            "\xDB\xA6\x54\x36\xBE\x1F\xD6\x64\x0F\x3D\xBF\x9A\x41\x42\x94\x95"
            "\x92\x45\x30\x28\x8F\xA3\xE5\xE2\x3E\x06\x02\x21\x00\xE4\xED\xC0"
            "\xDB\x3A\xC5\x72\xB1\xE2\xF5\xE8\xAB\x6A\x68\x06\x53\x98\x7D\xCF"
            "\x41\x02\x7D\xFE\xFF\xA1\x05\x51\x9D\x89\xED\xBF\x08";

    SETUP_CT_TEST_FIXTURE();

    SCT *sct = SCT_new();
    if (!SCT_set_version(sct, SCT_VERSION_V1)) {
        fprintf(stderr, "Failed to set SCT version\n");
        return 1;
    }
    if (!SCT_set1_log_id(sct, log_id, 32)) {
        fprintf(stderr, "Failed to set SCT log ID\n");
        return 1;
    }
    SCT_set_timestamp(sct, 1);
    if (!SCT_set_signature_nid(sct, NID_ecdsa_with_SHA256)) {
        fprintf(stderr, "Failed to set SCT signature NID\n");
        return 1;
    }
    if (!SCT_set1_signature(sct, signature, 71)) {
        fprintf(stderr, "Failed to set SCT signature\n");
        return 1;
    }
    fixture.sct = sct;
    fixture.sct_dir = ct_dir;
    fixture.sct_text_file = "tls1.sct";
    EXECUTE_CT_TEST();
}

int main(int argc, char *argv[])
{
    int result = 0;
    char *tmp_env = NULL;

    tmp_env = getenv("CT_DIR");
    ct_dir = OPENSSL_strdup(tmp_env != NULL ? tmp_env : "ct");
    tmp_env = getenv("CERTS_DIR");
    certs_dir = OPENSSL_strdup(tmp_env != NULL ? tmp_env : "certs");

    ADD_TEST(test_no_scts_in_certificate);
    ADD_TEST(test_one_sct_in_certificate);
    ADD_TEST(test_multiple_scts_in_certificate);
    ADD_TEST(test_verify_one_sct);
    ADD_TEST(test_verify_multiple_scts);
    ADD_TEST(test_decode_tls_sct);
    ADD_TEST(test_encode_tls_sct);

    result = run_tests(argv[0]);
    ERR_print_errors_fp(stderr);

    OPENSSL_free(ct_dir);
    OPENSSL_free(certs_dir);

    return result;
}

#else /* OPENSSL_NO_CT */

int main(int argc, char* argv[])
{
    return EXIT_SUCCESS;
}

#endif /* OPENSSL_NO_CT */
Commit	Line	Data
5dc31221	1	/*
2b2b9684	2	* Tests the Certificate Transparency public API.
5dc31221	3	*
7d054e5a	4	* Author: Rob Percival (robpercival@google.com)
5dc31221 RP	5	*
	6	* ====================================================================
	7	* Copyright (c) 2016 The OpenSSL Project. All rights reserved.
	8	*
	9	* Redistribution and use in source and binary forms, with or without
	10	* modification, are permitted provided that the following conditions
	11	* are met:
	12	*
	13	* 1. Redistributions of source code must retain the above copyright
	14	* notice, this list of conditions and the following disclaimer.
	15	*
	16	* 2. Redistributions in binary form must reproduce the above copyright
	17	* notice, this list of conditions and the following disclaimer in
	18	* the documentation and/or other materials provided with the
	19	* distribution.
	20	*
	21	* 3. All advertising materials mentioning features or use of this
	22	* software must display the following acknowledgment:
	23	* "This product includes software developed by the OpenSSL Project
	24	* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
	25	*
	26	* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
	27	* endorse or promote products derived from this software without
	28	* prior written permission. For written permission, please contact
	29	* licensing@OpenSSL.org.
	30	*
	31	* 5. Products derived from this software may not be called "OpenSSL"
	32	* nor may "OpenSSL" appear in their names without prior written
	33	* permission of the OpenSSL Project.
	34	*
	35	* 6. Redistributions of any form whatsoever must retain the following
	36	* acknowledgment:
	37	* "This product includes software developed by the OpenSSL Project
	38	* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
	39	*
	40	* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT AS IS'' AND ANY
	41	* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	42	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	43	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
	44	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	45	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	46	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	47	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	48	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	49	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	50	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
	51	* OF THE POSSIBILITY OF SUCH DAMAGE.
	52	* ====================================================================
	53	*/
	54
	55	#include <ctype.h>
	56	#include <stdio.h>
	57	#include <stdlib.h>
	58	#include <string.h>
	59
0cea8832	60	#include <openssl/ct.h>
17436ce5	61	#include <openssl/err.h>
2b2b9684	62	#include <openssl/pem.h>
17436ce5 RL	63	#include <openssl/x509.h>
17436ce5 RL	64	#include <openssl/x509v3.h>
5dc31221 RP	65	#include "testutil.h"
5dc31221 RP	66
11c8bc42	67	#ifndef OPENSSL_NO_CT
5dc31221 RP	68
	69	/* Used when declaring buffers to read text files into */
	70	#define CT_TEST_MAX_FILE_SIZE 8096
	71
67336ea4 RL	72	static char *certs_dir = NULL;
67336ea4 RL	73	static char *ct_dir = NULL;
c469a9a8	74
5dc31221 RP	75	typedef struct ct_test_fixture {
5dc31221 RP	76	const char *test_case_name;
7d054e5a RP	77	/* The CT log store to use during tests */
7d054e5a RP	78	CTLOG_STORE* ctlog_store;
5dc31221	79	/* Set the following to test handling of SCTs in X509 certificates */
c469a9a8 RL	80	const char *certs_dir;
	81	char *certificate_file;
	82	char *issuer_file;
7d054e5a	83	int expected_sct_count;
5dc31221	84	/* Set the following to test handling of SCTs in TLS format */
dc919c69	85	const unsigned char *tls_sct;
5dc31221	86	size_t tls_sct_len;
147e54a7	87	SCT *sct;
5dc31221 RP	88	/*
	89	* A file to load the expected SCT text from.
	90	* This text will be compared to the actual text output during the test.
	91	* A maximum of \|CT_TEST_MAX_FILE_SIZE\| bytes will be read of this file.
	92	*/
c469a9a8 RL	93	const char *sct_dir;
c469a9a8 RL	94	const char *sct_text_file;
7d054e5a RP	95	/* Whether to test the validity of the SCT(s) */
7d054e5a RP	96	int test_validity;
5dc31221 RP	97
	98	} CT_TEST_FIXTURE;
	99
	100	static CT_TEST_FIXTURE set_up(const char *const test_case_name)
	101	{
	102	CT_TEST_FIXTURE fixture;
	103	int setup_ok = 1;
7d054e5a RP	104	CTLOG_STORE *ctlog_store = CTLOG_STORE_new();
	105
	106	if (ctlog_store == NULL) {
	107	setup_ok = 0;
	108	fprintf(stderr, "Failed to create a new CT log store\n");
	109	goto end;
	110	}
	111
	112	if (CTLOG_STORE_load_default_file(ctlog_store) != 1) {
	113	setup_ok = 0;
	114	fprintf(stderr, "Failed to load CT log list\n");
	115	goto end;
	116	}
5dc31221 RP	117
	118	memset(&fixture, 0, sizeof(fixture));
	119	fixture.test_case_name = test_case_name;
7d054e5a	120	fixture.ctlog_store = ctlog_store;
5dc31221	121
7d054e5a	122	end:
5dc31221 RP	123	if (!setup_ok) {
	124	exit(EXIT_FAILURE);
	125	}
	126	return fixture;
	127	}
	128
	129	static void tear_down(CT_TEST_FIXTURE fixture)
	130	{
7d054e5a	131	CTLOG_STORE_free(fixture.ctlog_store);
147e54a7	132	SCT_free(fixture.sct);
5dc31221 RP	133	ERR_print_errors_fp(stderr);
	134	}
	135
c469a9a8 RL	136	static char mk_file_path(const char dir, const char *file)
	137	{
	138	char *full_file = NULL;
	139	size_t full_file_l = 0;
	140	const char *sep = "";
	141	#ifndef OPENSSL_SYS_VMS
	142	sep = "/";
	143	#endif
	144
	145	full_file_l = strlen(dir) + strlen(sep) + strlen(file) + 1;
	146	full_file = OPENSSL_zalloc(full_file_l);
	147	if (full_file != NULL) {
	148	OPENSSL_strlcpy(full_file, dir, full_file_l);
	149	OPENSSL_strlcat(full_file, sep, full_file_l);
	150	OPENSSL_strlcat(full_file, file, full_file_l);
	151	}
	152
	153	return full_file;
	154	}
	155
	156	static X509 load_pem_cert(const char dir, const char *file)
5dc31221	157	{
5dc31221	158	X509 *cert = NULL;
c469a9a8	159	char *file_path = mk_file_path(dir, file);
5dc31221	160
c469a9a8 RL	161	if (file_path != NULL) {
	162	BIO *cert_io = BIO_new_file(file_path, "r");
	163	OPENSSL_free(file_path);
5dc31221	164
c469a9a8 RL	165	if (cert_io != NULL)
c469a9a8 RL	166	cert = PEM_read_bio_X509(cert_io, NULL, NULL, NULL);
5dc31221	167
c469a9a8 RL	168	BIO_free(cert_io);
c469a9a8 RL	169	}
5dc31221 RP	170	return cert;
	171	}
	172
c469a9a8 RL	173	static int read_text_file(const char dir, const char file,
c469a9a8 RL	174	char *buffer, int buffer_length)
5dc31221	175	{
5dc31221	176	int result = -1;
c469a9a8 RL	177	char *file_path = mk_file_path(dir, file);
	178
	179	if (file_path != NULL) {
	180	BIO *file_io = BIO_new_file(file_path, "r");
	181	OPENSSL_free(file_path);
5dc31221	182
c469a9a8 RL	183	if (file_io != NULL) {
	184	result = BIO_read(file_io, buffer, buffer_length);
	185	BIO_free(file_io);
	186	}
5dc31221 RP	187	}
	188
	189	return result;
	190	}
	191
	192	static int compare_sct_printout(SCT *sct,
	193	const char *expected_output)
	194	{
	195	BIO *text_buffer = NULL;
	196	char *actual_output = NULL;
	197	int result = 1;
	198
	199	text_buffer = BIO_new(BIO_s_mem());
	200	if (text_buffer == NULL) {
	201	fprintf(stderr, "Unable to allocate buffer\n");
	202	goto end;
	203	}
	204
8359b57f	205	SCT_print(sct, text_buffer, 0, NULL);
5dc31221 RP	206
	207	/* Append null terminator because we're about to use the buffer contents
	208	* as a string. */
	209	if (BIO_write(text_buffer, "\0", 1) != 1) {
	210	fprintf(stderr, "Failed to append null terminator to SCT text\n");
	211	goto end;
	212	}
	213
	214	BIO_get_mem_data(text_buffer, &actual_output);
	215	result = strcmp(actual_output, expected_output);
	216
	217	if (result != 0) {
	218	fprintf(stderr,
	219	"Expected SCT printout:\n%s\nActual SCT printout:\n%s\n",
	220	expected_output, actual_output);
	221	}
	222
	223	end:
	224	BIO_free(text_buffer);
	225	return result;
	226	}
	227
	228	static int compare_extension_printout(X509_EXTENSION *extension,
	229	const char *expected_output)
	230	{
	231	BIO *text_buffer = NULL;
	232	char *actual_output = NULL;
	233	int result = 1;
	234
	235	text_buffer = BIO_new(BIO_s_mem());
	236	if (text_buffer == NULL) {
	237	fprintf(stderr, "Unable to allocate buffer\n");
	238	goto end;
	239	}
	240
	241	if (!X509V3_EXT_print(text_buffer, extension, X509V3_EXT_DEFAULT, 0)) {
	242	fprintf(stderr, "Failed to print extension\n");
	243	goto end;
	244	}
	245
	246	/* Append null terminator because we're about to use the buffer contents
	247	* as a string. */
	248	if (BIO_write(text_buffer, "\0", 1) != 1) {
	249	fprintf(stderr, "Failed to append null terminator to extension text\n");
	250	goto end;
	251	}
	252
	253	BIO_get_mem_data(text_buffer, &actual_output);
	254	result = strcmp(actual_output, expected_output);
	255
	256	if (result != 0) {
	257	fprintf(stderr,
	258	"Expected SCT printout:\n%s\nActual SCT printout:\n%s\n",
	259	expected_output, actual_output);
	260	}
	261
	262	end:
	263	BIO_free(text_buffer);
	264	return result;
	265	}
	266
	267	static int execute_cert_test(CT_TEST_FIXTURE fixture)
	268	{
7d054e5a RP	269	int test_failed = 0;
	270	X509 cert = NULL, issuer = NULL;
	271	STACK_OF(SCT) *scts = NULL;
5dc31221 RP	272	SCT *sct = NULL;
	273	char expected_sct_text[CT_TEST_MAX_FILE_SIZE];
	274	int sct_text_len = 0;
147e54a7 RP	275	unsigned char *tls_sct = NULL;
147e54a7 RP	276	size_t tls_sct_len = 0;
7d054e5a	277	CT_POLICY_EVAL_CTX *ct_policy_ctx = CT_POLICY_EVAL_CTX_new();
5dc31221	278
c469a9a8 RL	279	if (fixture.sct_text_file != NULL) {
	280	sct_text_len = read_text_file(fixture.sct_dir, fixture.sct_text_file,
	281	expected_sct_text,
	282	CT_TEST_MAX_FILE_SIZE - 1);
5dc31221 RP	283
5dc31221 RP	284	if (sct_text_len < 0) {
7d054e5a	285	test_failed = 1;
5dc31221	286	fprintf(stderr, "Test data file not found: %s\n",
c469a9a8	287	fixture.sct_text_file);
5dc31221 RP	288	goto end;
	289	}
	290
	291	expected_sct_text[sct_text_len] = '\0';
	292	}
	293
7d054e5a RP	294	CT_POLICY_EVAL_CTX_set0_log_store(ct_policy_ctx, fixture.ctlog_store);
7d054e5a RP	295
c469a9a8	296	if (fixture.certificate_file != NULL) {
5dc31221 RP	297	int sct_extension_index;
5dc31221 RP	298	X509_EXTENSION *sct_extension = NULL;
c469a9a8	299	cert = load_pem_cert(fixture.certs_dir, fixture.certificate_file);
5dc31221 RP	300
5dc31221 RP	301	if (cert == NULL) {
7d054e5a	302	test_failed = 1;
5dc31221	303	fprintf(stderr, "Unable to load certificate: %s\n",
c469a9a8	304	fixture.certificate_file);
5dc31221 RP	305	goto end;
	306	}
	307
7d054e5a RP	308	CT_POLICY_EVAL_CTX_set0_cert(ct_policy_ctx, cert);
7d054e5a RP	309
c469a9a8 RL	310	if (fixture.issuer_file != NULL) {
c469a9a8 RL	311	issuer = load_pem_cert(fixture.certs_dir, fixture.issuer_file);
7d054e5a RP	312
	313	if (issuer == NULL) {
	314	test_failed = 1;
	315	fprintf(stderr, "Unable to load issuer certificate: %s\n",
c469a9a8	316	fixture.issuer_file);
7d054e5a RP	317	goto end;
	318	}
	319
	320	CT_POLICY_EVAL_CTX_set0_issuer(ct_policy_ctx, issuer);
	321	}
	322
	323	sct_extension_index =
	324	X509_get_ext_by_NID(cert, NID_ct_precert_scts, -1);
5dc31221 RP	325	sct_extension = X509_get_ext(cert, sct_extension_index);
	326	if (fixture.expected_sct_count > 0) {
	327	if (sct_extension == NULL) {
7d054e5a	328	test_failed = 1;
5dc31221	329	fprintf(stderr, "SCT extension not found in: %s\n",
c469a9a8	330	fixture.certificate_file);
5dc31221 RP	331	goto end;
	332	}
	333
c469a9a8	334	if (fixture.sct_text_file) {
7d054e5a	335	test_failed = compare_extension_printout(sct_extension,
5dc31221	336	expected_sct_text);
7d054e5a RP	337	if (test_failed != 0)
	338	goto end;
	339	}
	340
	341	if (fixture.test_validity) {
	342	int are_scts_validated = 0;
14db9bbd RP	343	int i;
14db9bbd RP	344
7d054e5a	345	scts = X509V3_EXT_d2i(sct_extension);
14db9bbd RP	346	for (i = 0; i < sk_SCT_num(scts); ++i) {
	347	SCT *sct_i = sk_SCT_value(scts, i);
	348
	349	if (!SCT_set_source(sct_i, SCT_SOURCE_X509V3_EXTENSION)) {
	350	fprintf(stderr,
	351	"Error setting SCT source to X509v3 extension\n");
	352	test_failed = 1;
	353	goto end;
	354	}
5da65ef2	355	}
7d054e5a RP	356
	357	are_scts_validated = SCT_LIST_validate(scts, ct_policy_ctx);
	358	if (are_scts_validated < 0) {
	359	fprintf(stderr, "Error verifying SCTs\n");
	360	test_failed = 1;
	361	} else if (!are_scts_validated) {
	362	int invalid_sct_count = 0;
	363	int valid_sct_count = 0;
7d054e5a RP	364
	365	for (i = 0; i < sk_SCT_num(scts); ++i) {
	366	SCT *sct_i = sk_SCT_value(scts, i);
	367	switch (SCT_get_validation_status(sct_i)) {
	368	case SCT_VALIDATION_STATUS_VALID:
	369	++valid_sct_count;
	370	break;
	371	case SCT_VALIDATION_STATUS_INVALID:
	372	++invalid_sct_count;
	373	break;
	374	default:
	375	/* Ignore other validation statuses. */
	376	break;
	377	}
	378	}
	379
	380	if (valid_sct_count != fixture.expected_sct_count) {
	381	int unverified_sct_count = sk_SCT_num(scts) -
	382	invalid_sct_count - valid_sct_count;
	383
	384	fprintf(stderr,
	385	"%d SCTs failed verification\n"
	386	"%d SCTs passed verification (%d expected)\n"
	387	"%d SCTs were unverified\n",
	388	invalid_sct_count,
	389	valid_sct_count,
	390	fixture.expected_sct_count,
	391	unverified_sct_count);
	392	}
	393	test_failed = 1;
	394	}
	395
	396	if (test_failed != 0)
5dc31221 RP	397	goto end;
	398	}
	399	} else if (sct_extension != NULL) {
7d054e5a RP	400	test_failed = 1;
	401	fprintf(stderr,
	402	"Expected no SCTs, but found SCT extension in: %s\n",
c469a9a8	403	fixture.certificate_file);
5dc31221 RP	404	goto end;
	405	}
	406	}
	407
	408	if (fixture.tls_sct != NULL) {
	409	const unsigned char *p = fixture.tls_sct;
5dc31221	410	if (o2i_SCT(&sct, &p, fixture.tls_sct_len) == NULL) {
7d054e5a	411	test_failed = 1;
5dc31221 RP	412	fprintf(stderr, "Failed to decode SCT from TLS format\n");
	413	goto end;
	414	}
	415
c469a9a8	416	if (fixture.sct_text_file) {
7d054e5a RP	417	test_failed = compare_sct_printout(sct, expected_sct_text);
7d054e5a RP	418	if (test_failed != 0)
5dc31221 RP	419	goto end;
	420	}
	421
	422	tls_sct_len = i2o_SCT(sct, &tls_sct);
	423	if (tls_sct_len != fixture.tls_sct_len \|\|
	424	memcmp(fixture.tls_sct, tls_sct, tls_sct_len) != 0) {
7d054e5a	425	test_failed = 1;
5dc31221 RP	426	fprintf(stderr, "Failed to encode SCT into TLS format correctly\n");
	427	goto end;
	428	}
7d054e5a RP	429
	430	if (fixture.test_validity && cert != NULL) {
	431	int is_sct_validated = SCT_validate(sct, ct_policy_ctx);
	432	if (is_sct_validated < 0) {
	433	test_failed = 1;
	434	fprintf(stderr, "Error validating SCT\n");
	435	goto end;
	436	} else if (!is_sct_validated) {
	437	test_failed = 1;
	438	fprintf(stderr, "SCT failed verification\n");
	439	goto end;
	440	}
	441	}
5dc31221 RP	442	}
	443
	444	end:
	445	X509_free(cert);
7d054e5a RP	446	X509_free(issuer);
7d054e5a RP	447	SCT_LIST_free(scts);
5dc31221	448	SCT_free(sct);
7d054e5a	449	CT_POLICY_EVAL_CTX_free(ct_policy_ctx);
147e54a7	450	OPENSSL_free(tls_sct);
7d054e5a	451	return test_failed;
5dc31221 RP	452	}
	453
	454	#define SETUP_CT_TEST_FIXTURE() SETUP_TEST_FIXTURE(CT_TEST_FIXTURE, set_up)
	455	#define EXECUTE_CT_TEST() EXECUTE_TEST(execute_cert_test, tear_down)
	456
	457	static int test_no_scts_in_certificate()
	458	{
	459	SETUP_CT_TEST_FIXTURE();
c469a9a8 RL	460	fixture.certs_dir = certs_dir;
	461	fixture.certificate_file = "leaf.pem";
	462	fixture.issuer_file = "subinterCA.pem";
5dc31221 RP	463	fixture.expected_sct_count = 0;
	464	EXECUTE_CT_TEST();
	465	}
	466
	467	static int test_one_sct_in_certificate()
	468	{
	469	SETUP_CT_TEST_FIXTURE();
c469a9a8 RL	470	fixture.certs_dir = certs_dir;
	471	fixture.certificate_file = "embeddedSCTs1.pem";
	472	fixture.issuer_file = "embeddedSCTs1_issuer.pem";
5dc31221	473	fixture.expected_sct_count = 1;
c469a9a8 RL	474	fixture.sct_dir = certs_dir;
c469a9a8 RL	475	fixture.sct_text_file = "embeddedSCTs1.sct";
5dc31221 RP	476	EXECUTE_CT_TEST();
	477	}
	478
	479	static int test_multiple_scts_in_certificate()
	480	{
	481	SETUP_CT_TEST_FIXTURE();
c469a9a8 RL	482	fixture.certs_dir = certs_dir;
	483	fixture.certificate_file = "embeddedSCTs3.pem";
	484	fixture.issuer_file = "embeddedSCTs3_issuer.pem";
5dc31221	485	fixture.expected_sct_count = 3;
c469a9a8 RL	486	fixture.sct_dir = certs_dir;
c469a9a8 RL	487	fixture.sct_text_file = "embeddedSCTs3.sct";
5dc31221 RP	488	EXECUTE_CT_TEST();
	489	}
	490
7d054e5a RP	491	static int test_verify_one_sct()
	492	{
	493	SETUP_CT_TEST_FIXTURE();
c469a9a8 RL	494	fixture.certs_dir = certs_dir;
	495	fixture.certificate_file = "embeddedSCTs1.pem";
	496	fixture.issuer_file = "embeddedSCTs1_issuer.pem";
7d054e5a RP	497	fixture.expected_sct_count = 1;
	498	fixture.test_validity = 1;
	499	EXECUTE_CT_TEST();
	500	}
	501
	502	static int test_verify_multiple_scts()
	503	{
	504	SETUP_CT_TEST_FIXTURE();
c469a9a8 RL	505	fixture.certs_dir = certs_dir;
	506	fixture.certificate_file = "embeddedSCTs3.pem";
	507	fixture.issuer_file = "embeddedSCTs3_issuer.pem";
7d054e5a RP	508	fixture.expected_sct_count = 3;
	509	fixture.test_validity = 1;
	510	EXECUTE_CT_TEST();
	511	}
	512
5dc31221 RP	513	static int test_decode_tls_sct()
5dc31221 RP	514	{
dc919c69	515	const unsigned char tls_sct[] = "\x00" /* version */
5dc31221 RP	516	/* log ID */
	517	"\xDF\x1C\x2E\xC1\x15\x00\x94\x52\x47\xA9\x61\x68\x32\x5D\xDC\x5C\x79"
	518	"\x59\xE8\xF7\xC6\xD3\x88\xFC\x00\x2E\x0B\xBD\x3F\x74\xD7\x64"
	519	"\x00\x00\x01\x3D\xDB\x27\xDF\x93" /* timestamp */
	520	"\x00\x00" /* extensions length */
	521	"" /* extensions */
	522	"\x04\x03" /* hash and signature algorithms */
	523	"\x00\x47" /* signature length */
dc919c69	524	/* signature */
5dc31221 RP	525	"\x30\x45\x02\x20\x48\x2F\x67\x51\xAF\x35\xDB\xA6\x54\x36\xBE\x1F\xD6"
	526	"\x64\x0F\x3D\xBF\x9A\x41\x42\x94\x95\x92\x45\x30\x28\x8F\xA3\xE5\xE2"
	527	"\x3E\x06\x02\x21\x00\xE4\xED\xC0\xDB\x3A\xC5\x72\xB1\xE2\xF5\xE8\xAB"
	528	"\x6A\x68\x06\x53\x98\x7D\xCF\x41\x02\x7D\xFE\xFF\xA1\x05\x51\x9D\x89"
dc919c69 RP	529	"\xED\xBF\x08";
	530
	531	SETUP_CT_TEST_FIXTURE();
	532	fixture.tls_sct = tls_sct;
5dc31221	533	fixture.tls_sct_len = 118;
c469a9a8 RL	534	fixture.sct_dir = ct_dir;
c469a9a8 RL	535	fixture.sct_text_file = "tls1.sct";
5dc31221 RP	536	EXECUTE_CT_TEST();
	537	}
	538
	539	static int test_encode_tls_sct()
	540	{
dc919c69 RP	541	const unsigned char log_id[] = "\xDF\x1C\x2E\xC1\x15\x00\x94\x52\x47\xA9"
	542	"\x61\x68\x32\x5D\xDC\x5C\x79\x59\xE8\xF7\xC6\xD3\x88\xFC\x00\x2E"
	543	"\x0B\xBD\x3F\x74\xD7\x64";
	544
	545	const unsigned char signature[] = "\x45\x02\x20\x48\x2F\x67\x51\xAF\x35"
	546	"\xDB\xA6\x54\x36\xBE\x1F\xD6\x64\x0F\x3D\xBF\x9A\x41\x42\x94\x95"
	547	"\x92\x45\x30\x28\x8F\xA3\xE5\xE2\x3E\x06\x02\x21\x00\xE4\xED\xC0"
	548	"\xDB\x3A\xC5\x72\xB1\xE2\xF5\xE8\xAB\x6A\x68\x06\x53\x98\x7D\xCF"
	549	"\x41\x02\x7D\xFE\xFF\xA1\x05\x51\x9D\x89\xED\xBF\x08";
	550
5dc31221 RP	551	SETUP_CT_TEST_FIXTURE();
	552
	553	SCT *sct = SCT_new();
9c812014	554	if (!SCT_set_version(sct, SCT_VERSION_V1)) {
5da65ef2 RP	555	fprintf(stderr, "Failed to set SCT version\n");
	556	return 1;
	557	}
dc919c69	558	if (!SCT_set1_log_id(sct, log_id, 32)) {
5da65ef2 RP	559	fprintf(stderr, "Failed to set SCT log ID\n");
	560	return 1;
	561	}
5dc31221	562	SCT_set_timestamp(sct, 1);
5da65ef2 RP	563	if (!SCT_set_signature_nid(sct, NID_ecdsa_with_SHA256)) {
	564	fprintf(stderr, "Failed to set SCT signature NID\n");
	565	return 1;
	566	}
dc919c69	567	if (!SCT_set1_signature(sct, signature, 71)) {
5da65ef2 RP	568	fprintf(stderr, "Failed to set SCT signature\n");
	569	return 1;
	570	}
5dc31221	571	fixture.sct = sct;
c469a9a8 RL	572	fixture.sct_dir = ct_dir;
c469a9a8 RL	573	fixture.sct_text_file = "tls1.sct";
5dc31221	574	EXECUTE_CT_TEST();
5dc31221 RP	575	}
	576
	577	int main(int argc, char *argv[])
	578	{
	579	int result = 0;
c469a9a8 RL	580	char *tmp_env = NULL;
	581
	582	tmp_env = getenv("CT_DIR");
	583	ct_dir = OPENSSL_strdup(tmp_env != NULL ? tmp_env : "ct");
	584	tmp_env = getenv("CERTS_DIR");
	585	certs_dir = OPENSSL_strdup(tmp_env != NULL ? tmp_env : "certs");
5dc31221 RP	586
	587	ADD_TEST(test_no_scts_in_certificate);
	588	ADD_TEST(test_one_sct_in_certificate);
	589	ADD_TEST(test_multiple_scts_in_certificate);
7d054e5a RP	590	ADD_TEST(test_verify_one_sct);
7d054e5a RP	591	ADD_TEST(test_verify_multiple_scts);
5dc31221 RP	592	ADD_TEST(test_decode_tls_sct);
	593	ADD_TEST(test_encode_tls_sct);
	594
	595	result = run_tests(argv[0]);
	596	ERR_print_errors_fp(stderr);
	597
c469a9a8 RL	598	OPENSSL_free(ct_dir);
	599	OPENSSL_free(certs_dir);
	600
5dc31221 RP	601	return result;
	602	}
	603
	604	#else /* OPENSSL_NO_CT */
	605
	606	int main(int argc, char* argv[])
	607	{
	608	return EXIT_SUCCESS;
	609	}
	610
	611	#endif /* OPENSSL_NO_CT */