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