test/d2i_test.c

   1 /*
   2  * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 /* Regression tests for ASN.1 parsing bugs. */
  11
  12 #include <stdio.h>
  13 #include <string.h>
  14
  15 #include "testutil.h"
  16
  17 #include <openssl/asn1.h>
  18 #include <openssl/asn1t.h>
  19 #include <openssl/bio.h>
  20 #include <openssl/err.h>
  21 #include <openssl/x509.h>
  22 #include <openssl/x509v3.h>
  23 #include "e_os.h"
  24
  25 static const ASN1_ITEM *item_type;
  26 static const char *test_file;
  27
  28 typedef enum {
  29     ASN1_UNKNOWN,
  30     ASN1_OK,
  31     ASN1_BIO,
  32     ASN1_DECODE,
  33     ASN1_ENCODE,
  34     ASN1_COMPARE
  35 } expected_error_t;
  36
  37 typedef struct {
  38     const char *str;
  39     expected_error_t code;
  40 } error_enum;
  41
  42 static expected_error_t expected_error = ASN1_UNKNOWN;
  43
  44 typedef struct d2i_test_fixture {
  45     const char *test_case_name;
  46 } D2I_TEST_FIXTURE;
  47
  48 static D2I_TEST_FIXTURE set_up(const char *const test_case_name)
  49 {
  50     D2I_TEST_FIXTURE fixture;
  51     fixture.test_case_name = test_case_name;
  52     return fixture;
  53 }
  54
  55 static int execute_test(D2I_TEST_FIXTURE fixture)
  56 {
  57     BIO *bio = NULL;
  58     ASN1_VALUE *value = NULL;
  59     int ret = 0;
  60     unsigned char buf[2048];
  61     const unsigned char *buf_ptr = buf;
  62     unsigned char *der = NULL;
  63     int derlen;
  64     int len;
  65
  66     if ((bio = BIO_new_file(test_file, "r")) == NULL)
  67         return 0;
  68
  69     if (expected_error == ASN1_BIO) {
  70         value = ASN1_item_d2i_bio(item_type, bio, NULL);
  71         if (value == NULL)
  72             ret = 1;
  73         goto err;
  74     }
  75
  76     /*
  77      * Unless we are testing it we don't use ASN1_item_d2i_bio because it
  78      * performs sanity checks on the input and can reject it before the
  79      * decoder is called.
  80      */
  81     len = BIO_read(bio, buf, sizeof buf);
  82     if (len < 0)
  83         goto err;
  84
  85     value = ASN1_item_d2i(NULL, &buf_ptr, len, item_type);
  86     if (value == NULL) {
  87         if (expected_error == ASN1_DECODE)
  88             ret = 1;
  89         goto err;
  90     }
  91
  92     derlen = ASN1_item_i2d(value, &der, item_type);
  93
  94     if (der == NULL || derlen < 0) {
  95         if (expected_error == ASN1_ENCODE)
  96             ret = 1;
  97         goto err;
  98     }
  99
 100     if (derlen != len || memcmp(der, buf, derlen) != 0) {
 101         if (expected_error == ASN1_COMPARE)
 102             ret = 1;
 103         goto err;
 104     }
 105
 106     if (expected_error == ASN1_OK)
 107         ret = 1;
 108
 109  err:
 110     /* Don't indicate success for memory allocation errors */
 111     if (ret == 1 && ERR_GET_REASON(ERR_peek_error()) == ERR_R_MALLOC_FAILURE)
 112         ret = 0;
 113     BIO_free(bio);
 114     OPENSSL_free(der);
 115     ASN1_item_free(value, item_type);
 116     return ret;
 117 }
 118
 119 static void tear_down(D2I_TEST_FIXTURE fixture)
 120 {
 121     ERR_print_errors_fp(stderr);
 122 }
 123
 124 #define SETUP_D2I_TEST_FIXTURE() \
 125     SETUP_TEST_FIXTURE(D2I_TEST_FIXTURE, set_up)
 126
 127 #define EXECUTE_D2I_TEST() \
 128     EXECUTE_TEST(execute_test, tear_down)
 129
 130 static int test_bad_asn1()
 131 {
 132     SETUP_D2I_TEST_FIXTURE();
 133     EXECUTE_D2I_TEST();
 134 }
 135
 136 /*
 137  * Usage: d2i_test <type> <file>, e.g.
 138  * d2i_test generalname bad_generalname.der
 139  */
 140 int main(int argc, char **argv)
 141 {
 142     int result = 0;
 143     const char *test_type_name;
 144     const char *expected_error_string;
 145
 146     size_t i;
 147     static ASN1_ITEM_EXP *items[] = {
 148         ASN1_ITEM_ref(ASN1_ANY),
 149         ASN1_ITEM_ref(X509),
 150         ASN1_ITEM_ref(GENERAL_NAME),
 151         ASN1_ITEM_ref(ASN1_INTEGER)
 152     };
 153
 154     static error_enum expected_errors[] = {
 155         {"OK", ASN1_OK},
 156         {"BIO", ASN1_BIO},
 157         {"decode", ASN1_DECODE},
 158         {"encode", ASN1_ENCODE},
 159         {"compare", ASN1_COMPARE}
 160     };
 161
 162     if (argc != 4) {
 163         fprintf(stderr,
 164                 "Usage: d2i_test item_name expected_error file.der\n");
 165         return 1;
 166     }
 167
 168     test_type_name = argv[1];
 169     expected_error_string = argv[2];
 170     test_file = argv[3];
 171
 172     for (i = 0; i < OSSL_NELEM(items); i++) {
 173         const ASN1_ITEM *it = ASN1_ITEM_ptr(items[i]);
 174         if (strcmp(test_type_name, it->sname) == 0) {
 175             item_type = it;
 176             break;
 177         }
 178     }
 179     if (item_type == NULL) {
 180         fprintf(stderr, "Unknown type %s\n", test_type_name);
 181         fprintf(stderr, "Supported types:\n");
 182         for (i = 0; i < OSSL_NELEM(items); i++) {
 183             const ASN1_ITEM *it = ASN1_ITEM_ptr(items[i]);
 184             fprintf(stderr, "\t%s\n", it->sname);
 185         }
 186         return 1;
 187     }
 188
 189     for (i = 0; i < OSSL_NELEM(expected_errors); i++) {
 190         if (strcmp(expected_errors[i].str, expected_error_string) == 0) {
 191             expected_error = expected_errors[i].code;
 192             break;
 193         }
 194     }
 195
 196     if (expected_error == ASN1_UNKNOWN) {
 197         fprintf(stderr, "Unknown expected error %s\n", expected_error_string);
 198         return 1;
 199     }
 200
 201     ADD_TEST(test_bad_asn1);
 202
 203     result = run_tests(argv[0]);
 204
 205     return result;
 206 }