Convert SSL BIO to use SSL_write_ex().
[openssl.git] / ssl / bio_ssl.c
1 /*
2  * Copyright 1995-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 <stdio.h>
11 #include <stdlib.h>
12 #include <string.h>
13 #include <errno.h>
14 #include <openssl/crypto.h>
15 #include "internal/bio.h"
16 #include <openssl/err.h>
17 #include "ssl_locl.h"
18
19 static int ssl_write(BIO *h, const char *buf, size_t size, size_t *written);
20 static int ssl_read(BIO *b, char *buf, size_t size, size_t *readbytes);
21 static int ssl_puts(BIO *h, const char *str);
22 static long ssl_ctrl(BIO *h, int cmd, long arg1, void *arg2);
23 static int ssl_new(BIO *h);
24 static int ssl_free(BIO *data);
25 static long ssl_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp);
26 typedef struct bio_ssl_st {
27     SSL *ssl;                   /* The ssl handle :-) */
28     /* re-negotiate every time the total number of bytes is this size */
29     int num_renegotiates;
30     unsigned long renegotiate_count;
31     size_t byte_count;
32     unsigned long renegotiate_timeout;
33     unsigned long last_time;
34 } BIO_SSL;
35
36 static const BIO_METHOD methods_sslp = {
37     BIO_TYPE_SSL, "ssl",
38     ssl_write,
39     NULL,
40     ssl_read,
41     NULL,
42     ssl_puts,
43     NULL,                       /* ssl_gets, */
44     ssl_ctrl,
45     ssl_new,
46     ssl_free,
47     ssl_callback_ctrl,
48 };
49
50 const BIO_METHOD *BIO_f_ssl(void)
51 {
52     return (&methods_sslp);
53 }
54
55 static int ssl_new(BIO *bi)
56 {
57     BIO_SSL *bs = OPENSSL_zalloc(sizeof(*bs));
58
59     if (bs == NULL) {
60         BIOerr(BIO_F_SSL_NEW, ERR_R_MALLOC_FAILURE);
61         return (0);
62     }
63     BIO_set_init(bi, 0);
64     BIO_set_data(bi, bs);
65     /* Clear all flags */
66     BIO_clear_flags(bi, ~0);
67
68     return 1;
69 }
70
71 static int ssl_free(BIO *a)
72 {
73     BIO_SSL *bs;
74
75     if (a == NULL)
76         return (0);
77     bs = BIO_get_data(a);
78     if (bs->ssl != NULL)
79         SSL_shutdown(bs->ssl);
80     if (BIO_get_shutdown(a)) {
81         if (BIO_get_init(a))
82             SSL_free(bs->ssl);
83         /* Clear all flags */
84         BIO_clear_flags(a, ~0);
85         BIO_set_init(a, 0);
86     }
87     OPENSSL_free(bs);
88     return 1;
89 }
90
91 static int ssl_read(BIO *b, char *buf, size_t size, size_t *readbytes)
92 {
93     int ret = 1;
94     BIO_SSL *sb;
95     SSL *ssl;
96     int retry_reason = 0;
97     int r = 0;
98
99     if (buf == NULL)
100         return 0;
101     sb = BIO_get_data(b);
102     ssl = sb->ssl;
103
104     BIO_clear_retry_flags(b);
105
106     if (size > INT_MAX)
107         size = INT_MAX;
108
109     ret = SSL_read(ssl, buf, size);
110     if (ret > 0)
111         *readbytes = ret;
112
113     switch (SSL_get_error(ssl, ret)) {
114     case SSL_ERROR_NONE:
115         if (*readbytes == 0)
116             break;
117         if (sb->renegotiate_count > 0) {
118             sb->byte_count += *readbytes;
119             if (sb->byte_count > sb->renegotiate_count) {
120                 sb->byte_count = 0;
121                 sb->num_renegotiates++;
122                 SSL_renegotiate(ssl);
123                 r = 1;
124             }
125         }
126         if ((sb->renegotiate_timeout > 0) && (!r)) {
127             unsigned long tm;
128
129             tm = (unsigned long)time(NULL);
130             if (tm > sb->last_time + sb->renegotiate_timeout) {
131                 sb->last_time = tm;
132                 sb->num_renegotiates++;
133                 SSL_renegotiate(ssl);
134             }
135         }
136
137         break;
138     case SSL_ERROR_WANT_READ:
139         BIO_set_retry_read(b);
140         break;
141     case SSL_ERROR_WANT_WRITE:
142         BIO_set_retry_write(b);
143         break;
144     case SSL_ERROR_WANT_X509_LOOKUP:
145         BIO_set_retry_special(b);
146         retry_reason = BIO_RR_SSL_X509_LOOKUP;
147         break;
148     case SSL_ERROR_WANT_ACCEPT:
149         BIO_set_retry_special(b);
150         retry_reason = BIO_RR_ACCEPT;
151         break;
152     case SSL_ERROR_WANT_CONNECT:
153         BIO_set_retry_special(b);
154         retry_reason = BIO_RR_CONNECT;
155         break;
156     case SSL_ERROR_SYSCALL:
157     case SSL_ERROR_SSL:
158     case SSL_ERROR_ZERO_RETURN:
159     default:
160         break;
161     }
162
163     BIO_set_retry_reason(b, retry_reason);
164
165     return ret;
166 }
167
168 static int ssl_write(BIO *b, const char *buf, size_t size, size_t *written)
169 {
170     int ret, r = 0;
171     int retry_reason = 0;
172     SSL *ssl;
173     BIO_SSL *bs;
174
175     if (buf == NULL)
176         return 0;
177     bs = BIO_get_data(b);
178     ssl = bs->ssl;
179
180     BIO_clear_retry_flags(b);
181
182     ret = SSL_write_ex(ssl, buf, size, written);
183
184     switch (SSL_get_error(ssl, ret)) {
185     case SSL_ERROR_NONE:
186         if (*written == 0)
187             break;
188         if (bs->renegotiate_count > 0) {
189             bs->byte_count += *written;
190             if (bs->byte_count > bs->renegotiate_count) {
191                 bs->byte_count = 0;
192                 bs->num_renegotiates++;
193                 SSL_renegotiate(ssl);
194                 r = 1;
195             }
196         }
197         if ((bs->renegotiate_timeout > 0) && (!r)) {
198             unsigned long tm;
199
200             tm = (unsigned long)time(NULL);
201             if (tm > bs->last_time + bs->renegotiate_timeout) {
202                 bs->last_time = tm;
203                 bs->num_renegotiates++;
204                 SSL_renegotiate(ssl);
205             }
206         }
207         break;
208     case SSL_ERROR_WANT_WRITE:
209         BIO_set_retry_write(b);
210         break;
211     case SSL_ERROR_WANT_READ:
212         BIO_set_retry_read(b);
213         break;
214     case SSL_ERROR_WANT_X509_LOOKUP:
215         BIO_set_retry_special(b);
216         retry_reason = BIO_RR_SSL_X509_LOOKUP;
217         break;
218     case SSL_ERROR_WANT_CONNECT:
219         BIO_set_retry_special(b);
220         retry_reason = BIO_RR_CONNECT;
221     case SSL_ERROR_SYSCALL:
222     case SSL_ERROR_SSL:
223     default:
224         break;
225     }
226
227     BIO_set_retry_reason(b, retry_reason);
228
229     return ret;
230 }
231
232 static long ssl_ctrl(BIO *b, int cmd, long num, void *ptr)
233 {
234     SSL **sslp, *ssl;
235     BIO_SSL *bs, *dbs;
236     BIO *dbio, *bio;
237     long ret = 1;
238     BIO *next;
239
240     bs = BIO_get_data(b);
241     next = BIO_next(b);
242     ssl = bs->ssl;
243     if ((ssl == NULL) && (cmd != BIO_C_SET_SSL))
244         return (0);
245     switch (cmd) {
246     case BIO_CTRL_RESET:
247         SSL_shutdown(ssl);
248
249         if (ssl->handshake_func == ssl->method->ssl_connect)
250             SSL_set_connect_state(ssl);
251         else if (ssl->handshake_func == ssl->method->ssl_accept)
252             SSL_set_accept_state(ssl);
253
254         if (!SSL_clear(ssl)) {
255             ret = 0;
256             break;
257         }
258
259         if (next != NULL)
260             ret = BIO_ctrl(next, cmd, num, ptr);
261         else if (ssl->rbio != NULL)
262             ret = BIO_ctrl(ssl->rbio, cmd, num, ptr);
263         else
264             ret = 1;
265         break;
266     case BIO_CTRL_INFO:
267         ret = 0;
268         break;
269     case BIO_C_SSL_MODE:
270         if (num)                /* client mode */
271             SSL_set_connect_state(ssl);
272         else
273             SSL_set_accept_state(ssl);
274         break;
275     case BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT:
276         ret = bs->renegotiate_timeout;
277         if (num < 60)
278             num = 5;
279         bs->renegotiate_timeout = (unsigned long)num;
280         bs->last_time = (unsigned long)time(NULL);
281         break;
282     case BIO_C_SET_SSL_RENEGOTIATE_BYTES:
283         ret = bs->renegotiate_count;
284         if ((long)num >= 512)
285             bs->renegotiate_count = (unsigned long)num;
286         break;
287     case BIO_C_GET_SSL_NUM_RENEGOTIATES:
288         ret = bs->num_renegotiates;
289         break;
290     case BIO_C_SET_SSL:
291         if (ssl != NULL) {
292             ssl_free(b);
293             if (!ssl_new(b))
294                 return 0;
295         }
296         BIO_set_shutdown(b, num);
297         ssl = (SSL *)ptr;
298         bs->ssl = ssl;
299         bio = SSL_get_rbio(ssl);
300         if (bio != NULL) {
301             if (next != NULL)
302                 BIO_push(bio, next);
303             BIO_set_next(b, bio);
304             BIO_up_ref(bio);
305         }
306         BIO_set_init(b, 1);
307         break;
308     case BIO_C_GET_SSL:
309         if (ptr != NULL) {
310             sslp = (SSL **)ptr;
311             *sslp = ssl;
312         } else
313             ret = 0;
314         break;
315     case BIO_CTRL_GET_CLOSE:
316         ret = BIO_get_shutdown(b);
317         break;
318     case BIO_CTRL_SET_CLOSE:
319         BIO_set_shutdown(b, (int)num);
320         break;
321     case BIO_CTRL_WPENDING:
322         ret = BIO_ctrl(ssl->wbio, cmd, num, ptr);
323         break;
324     case BIO_CTRL_PENDING:
325         ret = SSL_pending(ssl);
326         if (ret == 0)
327             ret = BIO_pending(ssl->rbio);
328         break;
329     case BIO_CTRL_FLUSH:
330         BIO_clear_retry_flags(b);
331         ret = BIO_ctrl(ssl->wbio, cmd, num, ptr);
332         BIO_copy_next_retry(b);
333         break;
334     case BIO_CTRL_PUSH:
335         if ((next != NULL) && (next != ssl->rbio)) {
336             /*
337              * We are going to pass ownership of next to the SSL object...but
338              * we don't own a reference to pass yet - so up ref
339              */
340             BIO_up_ref(next);
341             SSL_set_bio(ssl, next, next);
342         }
343         break;
344     case BIO_CTRL_POP:
345         /* Only detach if we are the BIO explicitly being popped */
346         if (b == ptr) {
347             /* This will clear the reference we obtained during push */
348             SSL_set_bio(ssl, NULL, NULL);
349         }
350         break;
351     case BIO_C_DO_STATE_MACHINE:
352         BIO_clear_retry_flags(b);
353
354         BIO_set_retry_reason(b, 0);
355         ret = (int)SSL_do_handshake(ssl);
356
357         switch (SSL_get_error(ssl, (int)ret)) {
358         case SSL_ERROR_WANT_READ:
359             BIO_set_flags(b, BIO_FLAGS_READ | BIO_FLAGS_SHOULD_RETRY);
360             break;
361         case SSL_ERROR_WANT_WRITE:
362             BIO_set_flags(b, BIO_FLAGS_WRITE | BIO_FLAGS_SHOULD_RETRY);
363             break;
364         case SSL_ERROR_WANT_CONNECT:
365             BIO_set_flags(b, BIO_FLAGS_IO_SPECIAL | BIO_FLAGS_SHOULD_RETRY);
366             BIO_set_retry_reason(b, BIO_get_retry_reason(next));
367             break;
368         case SSL_ERROR_WANT_X509_LOOKUP:
369             BIO_set_retry_special(b);
370             BIO_set_retry_reason(b, BIO_RR_SSL_X509_LOOKUP);
371             break;
372         default:
373             break;
374         }
375         break;
376     case BIO_CTRL_DUP:
377         dbio = (BIO *)ptr;
378         dbs = BIO_get_data(dbio);
379         SSL_free(dbs->ssl);
380         dbs->ssl = SSL_dup(ssl);
381         dbs->num_renegotiates = bs->num_renegotiates;
382         dbs->renegotiate_count = bs->renegotiate_count;
383         dbs->byte_count = bs->byte_count;
384         dbs->renegotiate_timeout = bs->renegotiate_timeout;
385         dbs->last_time = bs->last_time;
386         ret = (dbs->ssl != NULL);
387         break;
388     case BIO_C_GET_FD:
389         ret = BIO_ctrl(ssl->rbio, cmd, num, ptr);
390         break;
391     case BIO_CTRL_SET_CALLBACK:
392         {
393 #if 0                           /* FIXME: Should this be used? -- Richard
394                                  * Levitte */
395             SSLerr(SSL_F_SSL_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
396             ret = -1;
397 #else
398             ret = 0;
399 #endif
400         }
401         break;
402     case BIO_CTRL_GET_CALLBACK:
403         {
404             void (**fptr) (const SSL *xssl, int type, int val);
405
406             fptr = (void (**)(const SSL *xssl, int type, int val))ptr;
407             *fptr = SSL_get_info_callback(ssl);
408         }
409         break;
410     default:
411         ret = BIO_ctrl(ssl->rbio, cmd, num, ptr);
412         break;
413     }
414     return (ret);
415 }
416
417 static long ssl_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
418 {
419     SSL *ssl;
420     BIO_SSL *bs;
421     long ret = 1;
422
423     bs = BIO_get_data(b);
424     ssl = bs->ssl;
425     switch (cmd) {
426     case BIO_CTRL_SET_CALLBACK:
427         {
428             /*
429              * FIXME: setting this via a completely different prototype seems
430              * like a crap idea
431              */
432             SSL_set_info_callback(ssl, (void (*)(const SSL *, int, int))fp);
433         }
434         break;
435     default:
436         ret = BIO_callback_ctrl(ssl->rbio, cmd, fp);
437         break;
438     }
439     return (ret);
440 }
441
442 static int ssl_puts(BIO *bp, const char *str)
443 {
444     int n, ret;
445
446     n = strlen(str);
447     ret = BIO_write(bp, str, n);
448     return (ret);
449 }
450
451 BIO *BIO_new_buffer_ssl_connect(SSL_CTX *ctx)
452 {
453 #ifndef OPENSSL_NO_SOCK
454     BIO *ret = NULL, *buf = NULL, *ssl = NULL;
455
456     if ((buf = BIO_new(BIO_f_buffer())) == NULL)
457         return (NULL);
458     if ((ssl = BIO_new_ssl_connect(ctx)) == NULL)
459         goto err;
460     if ((ret = BIO_push(buf, ssl)) == NULL)
461         goto err;
462     return (ret);
463  err:
464     BIO_free(buf);
465     BIO_free(ssl);
466 #endif
467     return (NULL);
468 }
469
470 BIO *BIO_new_ssl_connect(SSL_CTX *ctx)
471 {
472 #ifndef OPENSSL_NO_SOCK
473     BIO *ret = NULL, *con = NULL, *ssl = NULL;
474
475     if ((con = BIO_new(BIO_s_connect())) == NULL)
476         return (NULL);
477     if ((ssl = BIO_new_ssl(ctx, 1)) == NULL)
478         goto err;
479     if ((ret = BIO_push(ssl, con)) == NULL)
480         goto err;
481     return (ret);
482  err:
483     BIO_free(con);
484 #endif
485     return (NULL);
486 }
487
488 BIO *BIO_new_ssl(SSL_CTX *ctx, int client)
489 {
490     BIO *ret;
491     SSL *ssl;
492
493     if ((ret = BIO_new(BIO_f_ssl())) == NULL)
494         return (NULL);
495     if ((ssl = SSL_new(ctx)) == NULL) {
496         BIO_free(ret);
497         return (NULL);
498     }
499     if (client)
500         SSL_set_connect_state(ssl);
501     else
502         SSL_set_accept_state(ssl);
503
504     BIO_set_ssl(ret, ssl, BIO_CLOSE);
505     return (ret);
506 }
507
508 int BIO_ssl_copy_session_id(BIO *t, BIO *f)
509 {
510     BIO_SSL *tdata, *fdata;
511     t = BIO_find_type(t, BIO_TYPE_SSL);
512     f = BIO_find_type(f, BIO_TYPE_SSL);
513     if ((t == NULL) || (f == NULL))
514         return 0;
515     tdata = BIO_get_data(t);
516     fdata = BIO_get_data(f);
517     if ((tdata->ssl == NULL) || (fdata->ssl == NULL))
518         return (0);
519     if (!SSL_copy_session_id(tdata->ssl, (fdata->ssl)))
520         return 0;
521     return (1);
522 }
523
524 void BIO_ssl_shutdown(BIO *b)
525 {
526     SSL *s;
527
528     b = BIO_find_type(b, BIO_TYPE_SSL);
529     if (b == NULL)
530         return;
531
532     s = BIO_get_data(b);
533     SSL_shutdown(s);
534 }