42141fc26a2fb3f792ea2220daa1ef945b616981
[openssl.git] / test / ssltestlib.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 #include "ssltestlib.h"
11
12 static int tls_dump_new(BIO *bi);
13 static int tls_dump_free(BIO *a);
14 static int tls_dump_read(BIO *b, char *out, int outl);
15 static int tls_dump_write(BIO *b, const char *in, int inl);
16 static long tls_dump_ctrl(BIO *b, int cmd, long num, void *ptr);
17 static int tls_dump_gets(BIO *bp, char *buf, int size);
18 static int tls_dump_puts(BIO *bp, const char *str);
19
20 /* Choose a sufficiently large type likely to be unused for this custom BIO */
21 # define BIO_TYPE_TLS_DUMP_FILTER  (0x80 | BIO_TYPE_FILTER)
22
23 # define BIO_TYPE_MEMPACKET_TEST      0x81
24
25 static BIO_METHOD *method_tls_dump = NULL;
26 static BIO_METHOD *method_mempacket_test = NULL;
27
28 /* Note: Not thread safe! */
29 const BIO_METHOD *bio_f_tls_dump_filter(void)
30 {
31     if (method_tls_dump == NULL) {
32         method_tls_dump = BIO_meth_new(BIO_TYPE_TLS_DUMP_FILTER,
33                                         "TLS dump filter");
34         if (   method_tls_dump == NULL
35             || !BIO_meth_set_write(method_tls_dump, tls_dump_write)
36             || !BIO_meth_set_read(method_tls_dump, tls_dump_read)
37             || !BIO_meth_set_puts(method_tls_dump, tls_dump_puts)
38             || !BIO_meth_set_gets(method_tls_dump, tls_dump_gets)
39             || !BIO_meth_set_ctrl(method_tls_dump, tls_dump_ctrl)
40             || !BIO_meth_set_create(method_tls_dump, tls_dump_new)
41             || !BIO_meth_set_destroy(method_tls_dump, tls_dump_free))
42             return NULL;
43     }
44     return method_tls_dump;
45 }
46
47 void bio_f_tls_dump_filter_free(void)
48 {
49     BIO_meth_free(method_tls_dump);
50 }
51
52 static int tls_dump_new(BIO *bio)
53 {
54     BIO_set_init(bio, 1);
55     return 1;
56 }
57
58 static int tls_dump_free(BIO *bio)
59 {
60     BIO_set_init(bio, 0);
61
62     return 1;
63 }
64
65 static void copy_flags(BIO *bio)
66 {
67     int flags;
68     BIO *next = BIO_next(bio);
69
70     flags = BIO_test_flags(next, BIO_FLAGS_SHOULD_RETRY | BIO_FLAGS_RWS);
71     BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY | BIO_FLAGS_RWS);
72     BIO_set_flags(bio, flags);
73 }
74
75 #define RECORD_CONTENT_TYPE     0
76 #define RECORD_VERSION_HI       1
77 #define RECORD_VERSION_LO       2
78 #define RECORD_EPOCH_HI         3
79 #define RECORD_EPOCH_LO         4
80 #define RECORD_SEQUENCE_START   5
81 #define RECORD_SEQUENCE_END     10
82 #define RECORD_LEN_HI           11
83 #define RECORD_LEN_LO           12
84
85 #define MSG_TYPE                0
86 #define MSG_LEN_HI              1
87 #define MSG_LEN_MID             2
88 #define MSG_LEN_LO              3
89 #define MSG_SEQ_HI              4
90 #define MSG_SEQ_LO              5
91 #define MSG_FRAG_OFF_HI         6
92 #define MSG_FRAG_OFF_MID        7
93 #define MSG_FRAG_OFF_LO         8
94 #define MSG_FRAG_LEN_HI         9
95 #define MSG_FRAG_LEN_MID        10
96 #define MSG_FRAG_LEN_LO         11
97
98
99 static void dump_data(const char *data, int len)
100 {
101     int rem, i, content, reclen, msglen, fragoff, fraglen, epoch;
102     unsigned char *rec;
103
104     printf("---- START OF PACKET ----\n");
105
106     rem = len;
107     rec = (unsigned char *)data;
108
109     while (rem > 0) {
110         if (rem != len)
111             printf("*\n");
112         printf("*---- START OF RECORD ----\n");
113         if (rem < DTLS1_RT_HEADER_LENGTH) {
114             printf("*---- RECORD TRUNCATED ----\n");
115             break;
116         }
117         content = rec[RECORD_CONTENT_TYPE];
118         printf("** Record Content-type: %d\n", content);
119         printf("** Record Version: %02x%02x\n",
120                rec[RECORD_VERSION_HI], rec[RECORD_VERSION_LO]);
121         epoch = (rec[RECORD_EPOCH_HI] << 8) | rec[RECORD_EPOCH_LO];
122         printf("** Record Epoch: %d\n", epoch);
123         printf("** Record Sequence: ");
124         for (i = RECORD_SEQUENCE_START; i <= RECORD_SEQUENCE_END; i++)
125             printf("%02x", rec[i]);
126         reclen = (rec[RECORD_LEN_HI] << 8) | rec[RECORD_LEN_LO];
127         printf("\n** Record Length: %d\n", reclen);
128
129         /* Now look at message */
130         rec += DTLS1_RT_HEADER_LENGTH;
131         rem -= DTLS1_RT_HEADER_LENGTH;
132         if (content == SSL3_RT_HANDSHAKE) {
133             printf("**---- START OF HANDSHAKE MESSAGE FRAGMENT ----\n");
134             if (epoch > 0) {
135                 printf("**---- HANDSHAKE MESSAGE FRAGMENT ENCRYPTED ----\n");
136             } else if (rem < DTLS1_HM_HEADER_LENGTH
137                     || reclen < DTLS1_HM_HEADER_LENGTH) {
138                 printf("**---- HANDSHAKE MESSAGE FRAGMENT TRUNCATED ----\n");
139             } else {
140                 printf("*** Message Type: %d\n", rec[MSG_TYPE]);
141                 msglen = (rec[MSG_LEN_HI] << 16) | (rec[MSG_LEN_MID] << 8)
142                          | rec[MSG_LEN_LO];
143                 printf("*** Message Length: %d\n", msglen);
144                 printf("*** Message sequence: %d\n",
145                        (rec[MSG_SEQ_HI] << 8) | rec[MSG_SEQ_LO]);
146                 fragoff = (rec[MSG_FRAG_OFF_HI] << 16)
147                           | (rec[MSG_FRAG_OFF_MID] << 8)
148                           | rec[MSG_FRAG_OFF_LO];
149                 printf("*** Message Fragment offset: %d\n", fragoff);
150                 fraglen = (rec[MSG_FRAG_LEN_HI] << 16)
151                           | (rec[MSG_FRAG_LEN_MID] << 8)
152                           | rec[MSG_FRAG_LEN_LO];
153                 printf("*** Message Fragment len: %d\n", fraglen);
154                 if (fragoff + fraglen > msglen)
155                     printf("***---- HANDSHAKE MESSAGE FRAGMENT INVALID ----\n");
156                 else if(reclen < fraglen)
157                     printf("**---- HANDSHAKE MESSAGE FRAGMENT TRUNCATED ----\n");
158                 else
159                     printf("**---- END OF HANDSHAKE MESSAGE FRAGMENT ----\n");
160             }
161         }
162         if (rem < reclen) {
163             printf("*---- RECORD TRUNCATED ----\n");
164             rem = 0;
165         } else {
166             rec += reclen;
167             rem -= reclen;
168             printf("*---- END OF RECORD ----\n");
169         }
170     }
171     printf("---- END OF PACKET ----\n\n");
172     fflush(stdout);
173 }
174
175 static int tls_dump_read(BIO *bio, char *out, int outl)
176 {
177     int ret;
178     BIO *next = BIO_next(bio);
179
180     ret = BIO_read(next, out, outl);
181     copy_flags(bio);
182
183     if (ret > 0) {
184         dump_data(out, ret);
185     }
186
187     return ret;
188 }
189
190 static int tls_dump_write(BIO *bio, const char *in, int inl)
191 {
192     int ret;
193     BIO *next = BIO_next(bio);
194
195     ret = BIO_write(next, in, inl);
196     copy_flags(bio);
197
198     return ret;
199 }
200
201 static long tls_dump_ctrl(BIO *bio, int cmd, long num, void *ptr)
202 {
203     long ret;
204     BIO *next = BIO_next(bio);
205
206     if (next == NULL)
207         return 0;
208
209     switch (cmd) {
210     case BIO_CTRL_DUP:
211         ret = 0L;
212         break;
213     default:
214         ret = BIO_ctrl(next, cmd, num, ptr);
215         break;
216     }
217     return ret;
218 }
219
220 static int tls_dump_gets(BIO *bio, char *buf, int size)
221 {
222     /* We don't support this - not needed anyway */
223     return -1;
224 }
225
226 static int tls_dump_puts(BIO *bio, const char *str)
227 {
228     return tls_dump_write(bio, str, strlen(str));
229 }
230
231 int create_ssl_ctx_pair(const SSL_METHOD *sm, const SSL_METHOD *cm,
232                         SSL_CTX **sctx, SSL_CTX **cctx, char *certfile,
233                         char *privkeyfile)
234 {
235     SSL_CTX *serverctx = NULL;
236     SSL_CTX *clientctx = NULL;
237
238     serverctx = SSL_CTX_new(sm);
239     clientctx = SSL_CTX_new(cm);
240     if (serverctx == NULL || clientctx == NULL) {
241         printf("Failed to create SSL_CTX\n");
242         goto err;
243     }
244
245     if (SSL_CTX_use_certificate_file(serverctx, certfile,
246                                      SSL_FILETYPE_PEM) <= 0) {
247         printf("Failed to load server certificate\n");
248         goto err;
249     }
250     if (SSL_CTX_use_PrivateKey_file(serverctx, privkeyfile,
251                                     SSL_FILETYPE_PEM) <= 0) {
252         printf("Failed to load server private key\n");
253     }
254     if (SSL_CTX_check_private_key(serverctx) <= 0) {
255         printf("Failed to check private key\n");
256         goto err;
257     }
258
259     *sctx = serverctx;
260     *cctx = clientctx;
261
262     return 1;
263  err:
264     SSL_CTX_free(serverctx);
265     SSL_CTX_free(clientctx);
266     return 0;
267 }
268
269 #define MAXLOOPS    100000
270
271 /*
272  * NOTE: Transfers control of the BIOs - this function will free them on error
273  */
274 int create_ssl_connection(SSL_CTX *serverctx, SSL_CTX *clientctx, SSL **sssl,
275                           SSL **cssl, BIO *s_to_c_fbio, BIO *c_to_s_fbio)
276 {
277     int retc = -1, rets = -1, err, abortctr = 0;
278     int clienterr = 0, servererr = 0;
279     SSL *serverssl, *clientssl;
280     BIO *s_to_c_bio = NULL, *c_to_s_bio = NULL;
281
282     if (*sssl == NULL)
283         serverssl = SSL_new(serverctx);
284     else
285         serverssl = *sssl;
286     if (*cssl == NULL)
287         clientssl = SSL_new(clientctx);
288     else
289         clientssl = *cssl;
290
291     if (serverssl == NULL || clientssl == NULL) {
292         printf("Failed to create SSL object\n");
293         goto error;
294     }
295
296     s_to_c_bio = BIO_new(BIO_s_mem());
297     c_to_s_bio = BIO_new(BIO_s_mem());
298     if (s_to_c_bio == NULL || c_to_s_bio == NULL) {
299         printf("Failed to create mem BIOs\n");
300         goto error;
301     }
302
303     if (s_to_c_fbio != NULL)
304         s_to_c_bio = BIO_push(s_to_c_fbio, s_to_c_bio);
305     if (c_to_s_fbio != NULL)
306         c_to_s_bio = BIO_push(c_to_s_fbio, c_to_s_bio);
307     if (s_to_c_bio == NULL || c_to_s_bio == NULL) {
308         printf("Failed to create chained BIOs\n");
309         goto error;
310     }
311
312     /* Set Non-blocking IO behaviour */
313     BIO_set_mem_eof_return(s_to_c_bio, -1);
314     BIO_set_mem_eof_return(c_to_s_bio, -1);
315
316     /* Up ref these as we are passing them to two SSL objects */
317     BIO_up_ref(s_to_c_bio);
318     BIO_up_ref(c_to_s_bio);
319
320     SSL_set_bio(serverssl, c_to_s_bio, s_to_c_bio);
321     SSL_set_bio(clientssl, s_to_c_bio, c_to_s_bio);
322
323     /* BIOs will now be freed when SSL objects are freed */
324     s_to_c_bio = c_to_s_bio = NULL;
325     s_to_c_fbio = c_to_s_fbio = NULL;
326
327     do {
328         err = SSL_ERROR_WANT_WRITE;
329         while (!clienterr && retc <= 0 && err == SSL_ERROR_WANT_WRITE) {
330             retc = SSL_connect(clientssl);
331             if (retc <= 0)
332                 err = SSL_get_error(clientssl, retc);
333         }
334
335         if (!clienterr && retc <= 0 && err != SSL_ERROR_WANT_READ) {
336             printf("SSL_connect() failed %d, %d\n", retc, err);
337             clienterr = 1;
338         }
339
340         err = SSL_ERROR_WANT_WRITE;
341         while (!servererr && rets <= 0 && err == SSL_ERROR_WANT_WRITE) {
342             rets = SSL_accept(serverssl);
343             if (rets <= 0)
344                 err = SSL_get_error(serverssl, rets);
345         }
346
347         if (!servererr && rets <= 0 && err != SSL_ERROR_WANT_READ) {
348             printf("SSL_accept() failed %d, %d\n", retc, err);
349             servererr = 1;
350         }
351         if (clienterr && servererr)
352             goto error;
353         if (++abortctr == MAXLOOPS) {
354             printf("No progress made\n");
355             goto error;
356         }
357     } while (retc <=0 || rets <= 0);
358
359     *sssl = serverssl;
360     *cssl = clientssl;
361
362     return 1;
363
364  error:
365     if (*sssl == NULL) {
366         SSL_free(serverssl);
367         BIO_free(s_to_c_bio);
368         BIO_free(s_to_c_fbio);
369     }
370     if (*cssl == NULL) {
371         SSL_free(clientssl);
372         BIO_free(c_to_s_bio);
373         BIO_free(c_to_s_fbio);
374     }
375
376     return 0;
377 }