dd7bf11d00e9ea5526f8813ab6f9bfd978e35130
[openssl.git] / test / heartbeat_test.c
1 /*-
2  * Unit test for TLS heartbeats.
3  *
4  * Acts as a regression test against the Heartbleed bug (CVE-2014-0160).
5  *
6  * Author:  Mike Bland (mbland@acm.org, http://mike-bland.com/)
7  * Date:    2014-04-12
8  * License: Creative Commons Attribution 4.0 International (CC By 4.0)
9  *          http://creativecommons.org/licenses/by/4.0/deed.en_US
10  *
11  * OUTPUT
12  * ------
13  * The program returns zero on success. It will print a message with a count
14  * of the number of failed tests and return nonzero if any tests fail.
15  *
16  * It will print the contents of the request and response buffers for each
17  * failing test. In a "fixed" version, all the tests should pass and there
18  * should be no output.
19  *
20  * In a "bleeding" version, you'll see:
21  *
22  *   test_dtls1_heartbleed failed:
23  *     expected payload len: 0
24  *     received: 1024
25  *   sent 26 characters
26  *     "HEARTBLEED                "
27  *   received 1024 characters
28  *     "HEARTBLEED                \xde\xad\xbe\xef..."
29  *   ** test_dtls1_heartbleed failed **
30  *
31  * The contents of the returned buffer in the failing test will depend on the
32  * contents of memory on your machine.
33  *
34  * MORE INFORMATION
35  * ----------------
36  * http://mike-bland.com/2014/04/12/heartbleed.html
37  * http://mike-bland.com/tags/heartbleed.html
38  */
39
40 #define OPENSSL_UNIT_TEST
41
42 #include "../ssl/ssl_locl.h"
43
44 #include "testutil.h"
45 #include <ctype.h>
46 #include <stdio.h>
47 #include <stdlib.h>
48 #include <string.h>
49
50 #if !defined(OPENSSL_NO_HEARTBEATS) && !defined(OPENSSL_NO_UNIT_TEST)
51
52 /* As per https://tools.ietf.org/html/rfc6520#section-4 */
53 # define MIN_PADDING_SIZE        16
54
55 /* Maximum number of payload characters to print as test output */
56 # define MAX_PRINTABLE_CHARACTERS        1024
57
58 typedef struct heartbeat_test_fixture {
59     SSL_CTX *ctx;
60     SSL *s;
61     const char *test_case_name;
62     int (*process_heartbeat) (SSL *s, unsigned char *p, unsigned int length);
63     unsigned char *payload;
64     int sent_payload_len;
65     int expected_return_value;
66     int return_payload_offset;
67     int expected_payload_len;
68     const char *expected_return_payload;
69 } HEARTBEAT_TEST_FIXTURE;
70
71 static HEARTBEAT_TEST_FIXTURE set_up(const char *const test_case_name,
72                                      const SSL_METHOD *meth)
73 {
74     HEARTBEAT_TEST_FIXTURE fixture;
75     int setup_ok = 1;
76     memset(&fixture, 0, sizeof(fixture));
77     fixture.test_case_name = test_case_name;
78
79     fixture.ctx = SSL_CTX_new(meth);
80     if (!fixture.ctx) {
81         fprintf(stderr, "Failed to allocate SSL_CTX for test: %s\n",
82                 test_case_name);
83         setup_ok = 0;
84         goto fail;
85     }
86
87     fixture.s = SSL_new(fixture.ctx);
88     if (!fixture.s) {
89         fprintf(stderr, "Failed to allocate SSL for test: %s\n",
90                 test_case_name);
91         setup_ok = 0;
92         goto fail;
93     }
94
95     if (!ssl_init_wbio_buffer(fixture.s, 1)) {
96         fprintf(stderr, "Failed to set up wbio buffer for test: %s\n",
97                 test_case_name);
98         setup_ok = 0;
99         goto fail;
100     }
101
102     if (!ssl3_setup_buffers(fixture.s)) {
103         fprintf(stderr, "Failed to setup buffers for test: %s\n",
104                 test_case_name);
105         setup_ok = 0;
106         goto fail;
107     }
108
109     /*
110      * Clear the memory for the return buffer, since this isn't automatically
111      * zeroed in opt mode and will cause spurious test failures that will
112      * change with each execution.
113      */
114     memset(fixture.s->rlayer.wbuf.buf, 0, fixture.s->rlayer.wbuf.len);
115
116  fail:
117     if (!setup_ok) {
118         ERR_print_errors_fp(stderr);
119         exit(EXIT_FAILURE);
120     }
121     return fixture;
122 }
123
124 static HEARTBEAT_TEST_FIXTURE set_up_dtls(const char *const test_case_name)
125 {
126     HEARTBEAT_TEST_FIXTURE fixture = set_up(test_case_name,
127                                             DTLSv1_server_method());
128     fixture.process_heartbeat = dtls1_process_heartbeat;
129
130     /*
131      * As per dtls1_get_record(), skipping the following from the beginning
132      * of the returned heartbeat message: type-1 byte; version-2 bytes;
133      * sequence number-8 bytes; length-2 bytes And then skipping the 1-byte
134      * type encoded by process_heartbeat for a total of 14 bytes, at which
135      * point we can grab the length and the payload we seek.
136      */
137     fixture.return_payload_offset = 14;
138     return fixture;
139 }
140
141 /* Needed by ssl3_write_bytes() */
142 static int dummy_handshake(SSL *s)
143 {
144     return 1;
145 }
146
147 static HEARTBEAT_TEST_FIXTURE set_up_tls(const char *const test_case_name)
148 {
149     HEARTBEAT_TEST_FIXTURE fixture = set_up(test_case_name,
150                                             TLSv1_server_method());
151     fixture.process_heartbeat = tls1_process_heartbeat;
152     fixture.s->handshake_func = dummy_handshake;
153
154     /*
155      * As per do_ssl3_write(), skipping the following from the beginning of
156      * the returned heartbeat message: type-1 byte; version-2 bytes; length-2
157      * bytes And then skipping the 1-byte type encoded by process_heartbeat
158      * for a total of 6 bytes, at which point we can grab the length and the
159      * payload we seek.
160      */
161     fixture.return_payload_offset = 6;
162     return fixture;
163 }
164
165 static void tear_down(HEARTBEAT_TEST_FIXTURE fixture)
166 {
167     ERR_print_errors_fp(stderr);
168     SSL_free(fixture.s);
169     SSL_CTX_free(fixture.ctx);
170 }
171
172 static void print_payload(const char *const prefix,
173                           const unsigned char *payload, const int n)
174 {
175     const int end = n < MAX_PRINTABLE_CHARACTERS ? n
176         : MAX_PRINTABLE_CHARACTERS;
177     int i = 0;
178
179     printf("%s %d character%s", prefix, n, n == 1 ? "" : "s");
180     if (end != n)
181         printf(" (first %d shown)", end);
182     printf("\n  \"");
183
184     for (; i != end; ++i) {
185         const unsigned char c = payload[i];
186         if (isprint(c))
187             fputc(c, stdout);
188         else
189             printf("\\x%02x", c);
190     }
191     printf("\"\n");
192 }
193
194 static int execute_heartbeat(HEARTBEAT_TEST_FIXTURE fixture)
195 {
196     int result = 0;
197     SSL *s = fixture.s;
198     unsigned char *payload = fixture.payload;
199     unsigned char sent_buf[MAX_PRINTABLE_CHARACTERS + 1];
200     int return_value;
201     unsigned const char *p;
202     int actual_payload_len;
203
204     s->rlayer.rrec.data = payload;
205     s->rlayer.rrec.length = strlen((const char *)payload);
206     *payload++ = TLS1_HB_REQUEST;
207     s2n(fixture.sent_payload_len, payload);
208
209     /*
210      * Make a local copy of the request, since it gets overwritten at some
211      * point
212      */
213     memcpy(sent_buf, payload, sizeof(sent_buf));
214
215     return_value = fixture.process_heartbeat(s, s->rlayer.rrec.data,
216         s->rlayer.rrec.length);
217
218     if (return_value != fixture.expected_return_value) {
219         printf("%s failed: expected return value %d, received %d\n",
220                fixture.test_case_name, fixture.expected_return_value,
221                return_value);
222         result = 1;
223     }
224
225     /*
226      * If there is any byte alignment, it will be stored in wbuf.offset.
227      */
228     p = &(s->rlayer.
229           wbuf.buf[fixture.return_payload_offset + s->rlayer.wbuf.offset]);
230     actual_payload_len = 0;
231     n2s(p, actual_payload_len);
232
233     if (actual_payload_len != fixture.expected_payload_len) {
234         printf("%s failed:\n  expected payload len: %d\n  received: %d\n",
235                fixture.test_case_name, fixture.expected_payload_len,
236                actual_payload_len);
237         print_payload("sent", sent_buf, strlen((const char *)sent_buf));
238         print_payload("received", p, actual_payload_len);
239         result = 1;
240     } else {
241         char *actual_payload =
242             OPENSSL_strndup((const char *)p, actual_payload_len);
243         if (strcmp(actual_payload, fixture.expected_return_payload) != 0) {
244             printf
245                 ("%s failed:\n  expected payload: \"%s\"\n  received: \"%s\"\n",
246                  fixture.test_case_name, fixture.expected_return_payload,
247                  actual_payload);
248             result = 1;
249         }
250         OPENSSL_free(actual_payload);
251     }
252
253     if (result != 0) {
254         printf("** %s failed **\n--------\n", fixture.test_case_name);
255     }
256     return result;
257 }
258
259 static int honest_payload_size(unsigned char payload_buf[])
260 {
261     /* Omit three-byte pad at the beginning for type and payload length */
262     return strlen((const char *)&payload_buf[3]) - MIN_PADDING_SIZE;
263 }
264
265 # define SETUP_HEARTBEAT_TEST_FIXTURE(type)\
266   SETUP_TEST_FIXTURE(HEARTBEAT_TEST_FIXTURE, set_up_##type)
267
268 # define EXECUTE_HEARTBEAT_TEST()\
269   EXECUTE_TEST(execute_heartbeat, tear_down)
270
271 static int test_dtls1_not_bleeding()
272 {
273     SETUP_HEARTBEAT_TEST_FIXTURE(dtls);
274     /* Three-byte pad at the beginning for type and payload length */
275     unsigned char payload_buf[MAX_PRINTABLE_CHARACTERS + 4] =
276         "   Not bleeding, sixteen spaces of padding" "                ";
277     const int payload_buf_len = honest_payload_size(payload_buf);
278
279     fixture.payload = &payload_buf[0];
280     fixture.sent_payload_len = payload_buf_len;
281     fixture.expected_return_value = 0;
282     fixture.expected_payload_len = payload_buf_len;
283     fixture.expected_return_payload =
284         "Not bleeding, sixteen spaces of padding";
285     EXECUTE_HEARTBEAT_TEST();
286 }
287
288 static int test_dtls1_not_bleeding_empty_payload()
289 {
290     int payload_buf_len;
291
292     SETUP_HEARTBEAT_TEST_FIXTURE(dtls);
293     /*
294      * Three-byte pad at the beginning for type and payload length, plus a
295      * NUL at the end
296      */
297     unsigned char payload_buf[4 + MAX_PRINTABLE_CHARACTERS];
298     memset(payload_buf, ' ', MIN_PADDING_SIZE + 3);
299     payload_buf[MIN_PADDING_SIZE + 3] = '\0';
300     payload_buf_len = honest_payload_size(payload_buf);
301
302     fixture.payload = &payload_buf[0];
303     fixture.sent_payload_len = payload_buf_len;
304     fixture.expected_return_value = 0;
305     fixture.expected_payload_len = payload_buf_len;
306     fixture.expected_return_payload = "";
307     EXECUTE_HEARTBEAT_TEST();
308 }
309
310 static int test_dtls1_heartbleed()
311 {
312     SETUP_HEARTBEAT_TEST_FIXTURE(dtls);
313     /* Three-byte pad at the beginning for type and payload length */
314     unsigned char payload_buf[4 + MAX_PRINTABLE_CHARACTERS] =
315         "   HEARTBLEED                ";
316
317     fixture.payload = &payload_buf[0];
318     fixture.sent_payload_len = MAX_PRINTABLE_CHARACTERS;
319     fixture.expected_return_value = 0;
320     fixture.expected_payload_len = 0;
321     fixture.expected_return_payload = "";
322     EXECUTE_HEARTBEAT_TEST();
323 }
324
325 static int test_dtls1_heartbleed_empty_payload()
326 {
327     SETUP_HEARTBEAT_TEST_FIXTURE(dtls);
328     /*
329      * Excluding the NUL at the end, one byte short of type + payload length
330      * + minimum padding
331      */
332     unsigned char payload_buf[MAX_PRINTABLE_CHARACTERS + 4];
333     memset(payload_buf, ' ', MIN_PADDING_SIZE + 2);
334     payload_buf[MIN_PADDING_SIZE + 2] = '\0';
335
336     fixture.payload = &payload_buf[0];
337     fixture.sent_payload_len = MAX_PRINTABLE_CHARACTERS;
338     fixture.expected_return_value = 0;
339     fixture.expected_payload_len = 0;
340     fixture.expected_return_payload = "";
341     EXECUTE_HEARTBEAT_TEST();
342 }
343
344 static int test_dtls1_heartbleed_excessive_plaintext_length()
345 {
346     SETUP_HEARTBEAT_TEST_FIXTURE(dtls);
347     /*
348      * Excluding the NUL at the end, one byte in excess of maximum allowed
349      * heartbeat message length
350      */
351     unsigned char payload_buf[SSL3_RT_MAX_PLAIN_LENGTH + 2];
352     memset(payload_buf, ' ', sizeof(payload_buf));
353     payload_buf[sizeof(payload_buf) - 1] = '\0';
354
355     fixture.payload = &payload_buf[0];
356     fixture.sent_payload_len = honest_payload_size(payload_buf);
357     fixture.expected_return_value = 0;
358     fixture.expected_payload_len = 0;
359     fixture.expected_return_payload = "";
360     EXECUTE_HEARTBEAT_TEST();
361 }
362
363 static int test_tls1_not_bleeding()
364 {
365     SETUP_HEARTBEAT_TEST_FIXTURE(tls);
366     /* Three-byte pad at the beginning for type and payload length */
367     unsigned char payload_buf[MAX_PRINTABLE_CHARACTERS + 4] =
368         "   Not bleeding, sixteen spaces of padding" "                ";
369     const int payload_buf_len = honest_payload_size(payload_buf);
370
371     fixture.payload = &payload_buf[0];
372     fixture.sent_payload_len = payload_buf_len;
373     fixture.expected_return_value = 0;
374     fixture.expected_payload_len = payload_buf_len;
375     fixture.expected_return_payload =
376         "Not bleeding, sixteen spaces of padding";
377     EXECUTE_HEARTBEAT_TEST();
378 }
379
380 static int test_tls1_not_bleeding_empty_payload()
381 {
382     int payload_buf_len;
383
384     SETUP_HEARTBEAT_TEST_FIXTURE(tls);
385     /*
386      * Three-byte pad at the beginning for type and payload length, plus a
387      * NUL at the end
388      */
389     unsigned char payload_buf[4 + MAX_PRINTABLE_CHARACTERS];
390     memset(payload_buf, ' ', MIN_PADDING_SIZE + 3);
391     payload_buf[MIN_PADDING_SIZE + 3] = '\0';
392     payload_buf_len = honest_payload_size(payload_buf);
393
394     fixture.payload = &payload_buf[0];
395     fixture.sent_payload_len = payload_buf_len;
396     fixture.expected_return_value = 0;
397     fixture.expected_payload_len = payload_buf_len;
398     fixture.expected_return_payload = "";
399     EXECUTE_HEARTBEAT_TEST();
400 }
401
402 static int test_tls1_heartbleed()
403 {
404     SETUP_HEARTBEAT_TEST_FIXTURE(tls);
405     /* Three-byte pad at the beginning for type and payload length */
406     unsigned char payload_buf[MAX_PRINTABLE_CHARACTERS + 4] =
407         "   HEARTBLEED                ";
408
409     fixture.payload = &payload_buf[0];
410     fixture.sent_payload_len = MAX_PRINTABLE_CHARACTERS;
411     fixture.expected_return_value = 0;
412     fixture.expected_payload_len = 0;
413     fixture.expected_return_payload = "";
414     EXECUTE_HEARTBEAT_TEST();
415 }
416
417 static int test_tls1_heartbleed_empty_payload()
418 {
419     SETUP_HEARTBEAT_TEST_FIXTURE(tls);
420     /*
421      * Excluding the NUL at the end, one byte short of type + payload length
422      * + minimum padding
423      */
424     unsigned char payload_buf[MAX_PRINTABLE_CHARACTERS + 4];
425     memset(payload_buf, ' ', MIN_PADDING_SIZE + 2);
426     payload_buf[MIN_PADDING_SIZE + 2] = '\0';
427
428     fixture.payload = &payload_buf[0];
429     fixture.sent_payload_len = MAX_PRINTABLE_CHARACTERS;
430     fixture.expected_return_value = 0;
431     fixture.expected_payload_len = 0;
432     fixture.expected_return_payload = "";
433     EXECUTE_HEARTBEAT_TEST();
434 }
435
436 # undef EXECUTE_HEARTBEAT_TEST
437 # undef SETUP_HEARTBEAT_TEST_FIXTURE
438
439 int main(int argc, char *argv[])
440 {
441     int result = 0;
442
443     ADD_TEST(test_dtls1_not_bleeding);
444     ADD_TEST(test_dtls1_not_bleeding_empty_payload);
445     ADD_TEST(test_dtls1_heartbleed);
446     ADD_TEST(test_dtls1_heartbleed_empty_payload);
447     ADD_TEST(test_dtls1_heartbleed_excessive_plaintext_length);
448     ADD_TEST(test_tls1_not_bleeding);
449     ADD_TEST(test_tls1_not_bleeding_empty_payload);
450     ADD_TEST(test_tls1_heartbleed);
451     ADD_TEST(test_tls1_heartbleed_empty_payload);
452
453     result = run_tests(argv[0]);
454     ERR_print_errors_fp(stderr);
455     return result;
456 }
457
458 #else                           /* OPENSSL_NO_HEARTBEATS */
459
460 int main(int argc, char *argv[])
461 {
462     return EXIT_SUCCESS;
463 }
464 #endif                          /* OPENSSL_NO_HEARTBEATS */