Adding padding extension to trace code.
[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 #include "../ssl/ssl_locl.h"
42 #include <ctype.h>
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <string.h>
46
47 /* As per https://tools.ietf.org/html/rfc6520#section-4 */
48 #define MIN_PADDING_SIZE        16
49
50 /* Maximum number of payload characters to print as test output */
51 #define MAX_PRINTABLE_CHARACTERS        1024
52
53 typedef struct heartbeat_test_fixture
54         {
55         SSL_CTX *ctx;
56         SSL *s;
57         const char* test_case_name;
58         int (*process_heartbeat)(SSL* s);
59         unsigned char* payload;
60         int sent_payload_len;
61         int expected_return_value;
62         int return_payload_offset;
63         int expected_payload_len;
64         const char* expected_return_payload;
65         } HEARTBEAT_TEST_FIXTURE;
66
67 static HEARTBEAT_TEST_FIXTURE set_up(const char* const test_case_name,
68         const SSL_METHOD* meth)
69         {
70         HEARTBEAT_TEST_FIXTURE fixture;
71         int setup_ok = 1;
72         memset(&fixture, 0, sizeof(fixture));
73         fixture.test_case_name = test_case_name;
74
75         fixture.ctx = SSL_CTX_new(meth);
76         if (!fixture.ctx)
77                 {
78                 fprintf(stderr, "Failed to allocate SSL_CTX for test: %s\n",
79                         test_case_name);
80                 setup_ok = 0;
81                 goto fail;
82                 }
83
84         fixture.s = SSL_new(fixture.ctx);
85         if (!fixture.s)
86                 {
87                 fprintf(stderr, "Failed to allocate SSL for test: %s\n", test_case_name);
88                 setup_ok = 0;
89                 goto fail;
90                 }
91
92         if (!ssl_init_wbio_buffer(fixture.s, 1))
93                 {
94                 fprintf(stderr, "Failed to set up wbio buffer for test: %s\n",
95                         test_case_name);
96                 setup_ok = 0;
97                 goto fail;
98                 }
99
100         if (!ssl3_setup_buffers(fixture.s))
101                 {
102                 fprintf(stderr, "Failed to setup buffers for test: %s\n",
103                         test_case_name);
104                 setup_ok = 0;
105                 goto fail;
106                 }
107
108         /* Clear the memory for the return buffer, since this isn't automatically
109          * zeroed in opt mode and will cause spurious test failures that will change
110          * with each execution.
111          */
112         memset(fixture.s->s3->wbuf.buf, 0, fixture.s->s3->wbuf.len);
113
114         fail:
115         if (!setup_ok)
116                 {
117                 ERR_print_errors_fp(stderr);
118                 exit(EXIT_FAILURE);
119                 }
120         return fixture;
121         }
122
123 static HEARTBEAT_TEST_FIXTURE set_up_dtls(const char* const test_case_name)
124         {
125         HEARTBEAT_TEST_FIXTURE fixture = set_up(test_case_name,
126                 DTLSv1_server_method());
127         fixture.process_heartbeat = dtls1_process_heartbeat;
128
129         /* As per dtls1_get_record(), skipping the following from the beginning of
130          * the returned heartbeat message:
131          * type-1 byte; version-2 bytes; sequence number-8 bytes; length-2 bytes
132          *
133          * And then skipping the 1-byte type encoded by process_heartbeat for
134          * a total of 14 bytes, at which point we can grab the length and the
135          * 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         /* As per do_ssl3_write(), skipping the following from the beginning of
155          * the returned heartbeat message:
156          * type-1 byte; version-2 bytes; length-2 bytes
157          *
158          * And then skipping the 1-byte type encoded by process_heartbeat for
159          * a total of 6 bytes, at which point we can grab the length and the payload
160          * 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) printf(" (first %d shown)", end);
182         printf("\n  \"");
183
184         for (; i != end; ++i)
185                 {
186                 const unsigned char c = payload[i];
187                 if (isprint(c)) fputc(c, stdout);
188                 else printf("\\x%02x", c);
189                 }
190         printf("\"\n");
191 }
192
193 static int execute_heartbeat(HEARTBEAT_TEST_FIXTURE fixture)
194         {
195         int result = 0;
196         SSL* s = fixture.s;
197         unsigned char *payload = fixture.payload;
198         unsigned char sent_buf[MAX_PRINTABLE_CHARACTERS + 1];
199         int return_value;
200         unsigned const char *p;
201         int actual_payload_len;
202
203         s->s3->rrec.data = payload;
204         s->s3->rrec.length = strlen((const char*)payload);
205         *payload++ = TLS1_HB_REQUEST;
206         s2n(fixture.sent_payload_len, payload);
207
208         /* Make a local copy of the request, since it gets overwritten at some
209          * point */
210         memcpy((char *)sent_buf, (const char*)payload, sizeof(sent_buf));
211
212         return_value = fixture.process_heartbeat(s);
213
214         if (return_value != fixture.expected_return_value)
215                 {
216                 printf("%s failed: expected return value %d, received %d\n",
217                                          fixture.test_case_name, fixture.expected_return_value,
218                                          return_value);
219                 result = 1;
220                 }
221
222         /* If there is any byte alignment, it will be stored in wbuf.offset. */
223         p = &(s->s3->wbuf.buf[
224                         fixture.return_payload_offset + s->s3->wbuf.offset]);
225         actual_payload_len = 0;
226         n2s(p, actual_payload_len);
227
228         if (actual_payload_len != fixture.expected_payload_len)
229                 {
230                 printf("%s failed:\n  expected payload len: %d\n  received: %d\n",
231                                          fixture.test_case_name, fixture.expected_payload_len,
232                                          actual_payload_len);
233                 print_payload("sent", sent_buf, strlen((const char*)sent_buf));
234                 print_payload("received", p, actual_payload_len);
235                 result = 1;
236                 }
237         else
238                 {
239                 char* actual_payload = strndup((const char*)p, actual_payload_len);
240                 if (strcmp(actual_payload, fixture.expected_return_payload) != 0)
241                         {
242                         printf("%s failed:\n  expected payload: \"%s\"\n  received: \"%s\"\n",
243                                                  fixture.test_case_name, fixture.expected_return_payload,
244                                                  actual_payload);
245                         result = 1;
246                         }
247                 free(actual_payload);
248                 }
249
250         if (result != 0)
251                 {
252                 printf("** %s failed **\n--------\n", fixture.test_case_name);
253                 }
254         return result;
255         }
256
257 static int honest_payload_size(unsigned char payload_buf[])
258         {
259         /* Omit three-byte pad at the beginning for type and payload length */
260         return strlen((const char*)&payload_buf[3]) - MIN_PADDING_SIZE;
261         }
262
263 #define SETUP_HEARTBEAT_TEST_FIXTURE(type)\
264         HEARTBEAT_TEST_FIXTURE fixture = set_up_##type(__func__);\
265         int result = 0
266
267 #define EXECUTE_HEARTBEAT_TEST()\
268         if (execute_heartbeat(fixture) != 0) result = 1;\
269         tear_down(fixture);\
270         return result
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[] = "   Not bleeding, sixteen spaces of padding"
277                 "                ";
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 = "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         /* Three-byte pad at the beginning for type and payload length, plus a NUL
294          * at the end */
295         unsigned char payload_buf[4 + MIN_PADDING_SIZE];
296         memset(payload_buf, ' ', sizeof(payload_buf));
297         payload_buf[sizeof(payload_buf) - 1] = '\0';
298         payload_buf_len = honest_payload_size(payload_buf);
299
300         fixture.payload = &payload_buf[0];
301         fixture.sent_payload_len = payload_buf_len;
302         fixture.expected_return_value = 0;
303         fixture.expected_payload_len = payload_buf_len;
304         fixture.expected_return_payload = "";
305         EXECUTE_HEARTBEAT_TEST();
306         }
307
308 static int test_dtls1_heartbleed()
309         {
310         SETUP_HEARTBEAT_TEST_FIXTURE(dtls);
311         /* Three-byte pad at the beginning for type and payload length */
312         unsigned char payload_buf[] = "   HEARTBLEED                ";
313
314         fixture.payload = &payload_buf[0];
315         fixture.sent_payload_len = MAX_PRINTABLE_CHARACTERS;
316         fixture.expected_return_value = 0;
317         fixture.expected_payload_len = 0;
318         fixture.expected_return_payload = "";
319         EXECUTE_HEARTBEAT_TEST();
320         }
321
322 static int test_dtls1_heartbleed_empty_payload()
323         {
324         SETUP_HEARTBEAT_TEST_FIXTURE(dtls);
325         /* Excluding the NUL at the end, one byte short of type + payload length +
326          * minimum padding */
327         unsigned char payload_buf[MIN_PADDING_SIZE + 3];
328         memset(payload_buf, ' ', sizeof(payload_buf));
329         payload_buf[sizeof(payload_buf) - 1] = '\0';
330
331         fixture.payload = &payload_buf[0];
332         fixture.sent_payload_len = MAX_PRINTABLE_CHARACTERS;
333         fixture.expected_return_value = 0;
334         fixture.expected_payload_len = 0;
335         fixture.expected_return_payload = "";
336         EXECUTE_HEARTBEAT_TEST();
337         }
338
339 static int test_dtls1_heartbleed_excessive_plaintext_length()
340         {
341         SETUP_HEARTBEAT_TEST_FIXTURE(dtls);
342         /* Excluding the NUL at the end, one byte in excess of maximum allowed
343          * heartbeat message length */
344         unsigned char payload_buf[SSL3_RT_MAX_PLAIN_LENGTH + 2];
345         memset(payload_buf, ' ', sizeof(payload_buf));
346         payload_buf[sizeof(payload_buf) - 1] = '\0';
347
348         fixture.payload = &payload_buf[0];
349         fixture.sent_payload_len = honest_payload_size(payload_buf);
350         fixture.expected_return_value = 0;
351         fixture.expected_payload_len = 0;
352         fixture.expected_return_payload = "";
353         EXECUTE_HEARTBEAT_TEST();
354         }
355
356 static int test_tls1_not_bleeding()
357         {
358         SETUP_HEARTBEAT_TEST_FIXTURE(tls);
359         /* Three-byte pad at the beginning for type and payload length */
360         unsigned char payload_buf[] = "   Not bleeding, sixteen spaces of padding"
361                                         "                ";
362         const int payload_buf_len = honest_payload_size(payload_buf);
363
364         fixture.payload = &payload_buf[0];
365         fixture.sent_payload_len = payload_buf_len;
366         fixture.expected_return_value = 0;
367         fixture.expected_payload_len = payload_buf_len;
368         fixture.expected_return_payload = "Not bleeding, sixteen spaces of padding";
369         EXECUTE_HEARTBEAT_TEST();
370         }
371
372 static int test_tls1_not_bleeding_empty_payload()
373         {
374         int payload_buf_len;
375
376         SETUP_HEARTBEAT_TEST_FIXTURE(tls);
377         /* Three-byte pad at the beginning for type and payload length, plus a NUL
378          * at the end */
379         unsigned char payload_buf[4 + MIN_PADDING_SIZE];
380         memset(payload_buf, ' ', sizeof(payload_buf));
381         payload_buf[sizeof(payload_buf) - 1] = '\0';
382         payload_buf_len = honest_payload_size(payload_buf);
383
384         fixture.payload = &payload_buf[0];
385         fixture.sent_payload_len = payload_buf_len;
386         fixture.expected_return_value = 0;
387         fixture.expected_payload_len = payload_buf_len;
388         fixture.expected_return_payload = "";
389         EXECUTE_HEARTBEAT_TEST();
390         }
391
392 static int test_tls1_heartbleed()
393         {
394         SETUP_HEARTBEAT_TEST_FIXTURE(tls);
395         /* Three-byte pad at the beginning for type and payload length */
396         unsigned char payload_buf[] = "   HEARTBLEED                ";
397
398         fixture.payload = &payload_buf[0];
399         fixture.sent_payload_len = MAX_PRINTABLE_CHARACTERS;
400         fixture.expected_return_value = 0;
401         fixture.expected_payload_len = 0;
402         fixture.expected_return_payload = "";
403         EXECUTE_HEARTBEAT_TEST();
404         }
405
406 static int test_tls1_heartbleed_empty_payload()
407         {
408         SETUP_HEARTBEAT_TEST_FIXTURE(tls);
409         /* Excluding the NUL at the end, one byte short of type + payload length +
410          * minimum padding */
411         unsigned char payload_buf[MIN_PADDING_SIZE + 3];
412         memset(payload_buf, ' ', sizeof(payload_buf));
413         payload_buf[sizeof(payload_buf) - 1] = '\0';
414
415         fixture.payload = &payload_buf[0];
416         fixture.sent_payload_len = MAX_PRINTABLE_CHARACTERS;
417         fixture.expected_return_value = 0;
418         fixture.expected_payload_len = 0;
419         fixture.expected_return_payload = "";
420         EXECUTE_HEARTBEAT_TEST();
421         }
422
423 #undef EXECUTE_HEARTBEAT_TEST
424 #undef SETUP_HEARTBEAT_TEST_FIXTURE
425
426 int main(int argc, char *argv[])
427         {
428         int num_failed;
429
430         SSL_library_init();
431         SSL_load_error_strings();
432
433         num_failed = test_dtls1_not_bleeding() +
434             test_dtls1_not_bleeding_empty_payload() +
435             test_dtls1_heartbleed() +
436             test_dtls1_heartbleed_empty_payload() +
437             /* The following test causes an assertion failure at
438              * ssl/d1_pkt.c:dtls1_write_bytes() in versions prior to 1.0.1g: */
439             (OPENSSL_VERSION_NUMBER >= 0x1000107fL ?
440              test_dtls1_heartbleed_excessive_plaintext_length() : 0) +
441             test_tls1_not_bleeding() +
442             test_tls1_not_bleeding_empty_payload() +
443             test_tls1_heartbleed() +
444             test_tls1_heartbleed_empty_payload() +
445             0;
446
447         ERR_print_errors_fp(stderr);
448
449         if (num_failed != 0)
450                 {
451                 printf("%d test%s failed\n", num_failed, num_failed != 1 ? "s" : "");
452                 return EXIT_FAILURE;
453                 }
454         return EXIT_SUCCESS;
455         }