e06c580871ee12207c08b3b2a26948c4daa8a977
[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 num, size_t *written);
20 static int ssl_read(BIO *b, char *out, size_t outl, size_t *read);
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     unsigned long 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 *out, size_t outl, size_t *read)
92 {
93     int ret = 1;
94     BIO_SSL *sb;
95     SSL *ssl;
96     int retry_reason = 0;
97     int r = 0;
98
99     if (out == NULL)
100         return (0);
101     sb = BIO_get_data(b);
102     ssl = sb->ssl;
103
104     BIO_clear_retry_flags(b);
105
106     if (outl > INT_MAX)
107         return -1;
108
109     ret = SSL_read(ssl, out, outl);
110     if (ret > 0)
111         *read = ret;
112
113     switch (SSL_get_error(ssl, ret)) {
114     case SSL_ERROR_NONE:
115         if (ret <= 0)
116             break;
117         if (sb->renegotiate_count > 0) {
118             sb->byte_count += *read;
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 *out, size_t outl, size_t *written)
169 {
170     int ret, r = 0;
171     int retry_reason = 0;
172     SSL *ssl;
173     BIO_SSL *bs;
174
175     if (out == NULL)
176         return (0);
177     bs = BIO_get_data(b);
178     ssl = bs->ssl;
179
180     BIO_clear_retry_flags(b);
181
182     if (outl > INT_MAX)
183         return 0;
184
185     ret = SSL_write(ssl, out, outl);
186
187     switch (SSL_get_error(ssl, ret)) {
188     case SSL_ERROR_NONE:
189         if (ret <= 0)
190             break;
191         if (bs->renegotiate_count > 0) {
192             bs->byte_count += ret;
193             if (bs->byte_count > bs->renegotiate_count) {
194                 bs->byte_count = 0;
195                 bs->num_renegotiates++;
196                 SSL_renegotiate(ssl);
197                 r = 1;
198             }
199         }
200         if ((bs->renegotiate_timeout > 0) && (!r)) {
201             unsigned long tm;
202
203             tm = (unsigned long)time(NULL);
204             if (tm > bs->last_time + bs->renegotiate_timeout) {
205                 bs->last_time = tm;
206                 bs->num_renegotiates++;
207                 SSL_renegotiate(ssl);
208             }
209         }
210         break;
211     case SSL_ERROR_WANT_WRITE:
212         BIO_set_retry_write(b);
213         break;
214     case SSL_ERROR_WANT_READ:
215         BIO_set_retry_read(b);
216         break;
217     case SSL_ERROR_WANT_X509_LOOKUP:
218         BIO_set_retry_special(b);
219         retry_reason = BIO_RR_SSL_X509_LOOKUP;
220         break;
221     case SSL_ERROR_WANT_CONNECT:
222         BIO_set_retry_special(b);
223         retry_reason = BIO_RR_CONNECT;
224     case SSL_ERROR_SYSCALL:
225     case SSL_ERROR_SSL:
226     default:
227         break;
228     }
229
230     BIO_set_retry_reason(b, retry_reason);
231
232     if (ret > 0) {
233         *written = ret;
234         ret = 1;
235     }
236
237     return ret;
238 }
239
240 static long ssl_ctrl(BIO *b, int cmd, long num, void *ptr)
241 {
242     SSL **sslp, *ssl;
243     BIO_SSL *bs, *dbs;
244     BIO *dbio, *bio;
245     long ret = 1;
246     BIO *next;
247
248     bs = BIO_get_data(b);
249     next = BIO_next(b);
250     ssl = bs->ssl;
251     if ((ssl == NULL) && (cmd != BIO_C_SET_SSL))
252         return (0);
253     switch (cmd) {
254     case BIO_CTRL_RESET:
255         SSL_shutdown(ssl);
256
257         if (ssl->handshake_func == ssl->method->ssl_connect)
258             SSL_set_connect_state(ssl);
259         else if (ssl->handshake_func == ssl->method->ssl_accept)
260             SSL_set_accept_state(ssl);
261
262         if (!SSL_clear(ssl)) {
263             ret = 0;
264             break;
265         }
266
267         if (next != NULL)
268             ret = BIO_ctrl(next, cmd, num, ptr);
269         else if (ssl->rbio != NULL)
270             ret = BIO_ctrl(ssl->rbio, cmd, num, ptr);
271         else
272             ret = 1;
273         break;
274     case BIO_CTRL_INFO:
275         ret = 0;
276         break;
277     case BIO_C_SSL_MODE:
278         if (num)                /* client mode */
279             SSL_set_connect_state(ssl);
280         else
281             SSL_set_accept_state(ssl);
282         break;
283     case BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT:
284         ret = bs->renegotiate_timeout;
285         if (num < 60)
286             num = 5;
287         bs->renegotiate_timeout = (unsigned long)num;
288         bs->last_time = (unsigned long)time(NULL);
289         break;
290     case BIO_C_SET_SSL_RENEGOTIATE_BYTES:
291         ret = bs->renegotiate_count;
292         if ((long)num >= 512)
293             bs->renegotiate_count = (unsigned long)num;
294         break;
295     case BIO_C_GET_SSL_NUM_RENEGOTIATES:
296         ret = bs->num_renegotiates;
297         break;
298     case BIO_C_SET_SSL:
299         if (ssl != NULL) {
300             ssl_free(b);
301             if (!ssl_new(b))
302                 return 0;
303         }
304         BIO_set_shutdown(b, num);
305         ssl = (SSL *)ptr;
306         bs->ssl = ssl;
307         bio = SSL_get_rbio(ssl);
308         if (bio != NULL) {
309             if (next != NULL)
310                 BIO_push(bio, next);
311             BIO_set_next(b, bio);
312             BIO_up_ref(bio);
313         }
314         BIO_set_init(b, 1);
315         break;
316     case BIO_C_GET_SSL:
317         if (ptr != NULL) {
318             sslp = (SSL **)ptr;
319             *sslp = ssl;
320         } else
321             ret = 0;
322         break;
323     case BIO_CTRL_GET_CLOSE:
324         ret = BIO_get_shutdown(b);
325         break;
326     case BIO_CTRL_SET_CLOSE:
327         BIO_set_shutdown(b, (int)num);
328         break;
329     case BIO_CTRL_WPENDING:
330         ret = BIO_ctrl(ssl->wbio, cmd, num, ptr);
331         break;
332     case BIO_CTRL_PENDING:
333         ret = SSL_pending(ssl);
334         if (ret == 0)
335             ret = BIO_pending(ssl->rbio);
336         break;
337     case BIO_CTRL_FLUSH:
338         BIO_clear_retry_flags(b);
339         ret = BIO_ctrl(ssl->wbio, cmd, num, ptr);
340         BIO_copy_next_retry(b);
341         break;
342     case BIO_CTRL_PUSH:
343         if ((next != NULL) && (next != ssl->rbio)) {
344             /*
345              * We are going to pass ownership of next to the SSL object...but
346              * we don't own a reference to pass yet - so up ref
347              */
348             BIO_up_ref(next);
349             SSL_set_bio(ssl, next, next);
350         }
351         break;
352     case BIO_CTRL_POP:
353         /* Only detach if we are the BIO explicitly being popped */
354         if (b == ptr) {
355             /* This will clear the reference we obtained during push */
356             SSL_set_bio(ssl, NULL, NULL);
357         }
358         break;
359     case BIO_C_DO_STATE_MACHINE:
360         BIO_clear_retry_flags(b);
361
362         BIO_set_retry_reason(b, 0);
363         ret = (int)SSL_do_handshake(ssl);
364
365         switch (SSL_get_error(ssl, (int)ret)) {
366         case SSL_ERROR_WANT_READ:
367             BIO_set_flags(b, BIO_FLAGS_READ | BIO_FLAGS_SHOULD_RETRY);
368             break;
369         case SSL_ERROR_WANT_WRITE:
370             BIO_set_flags(b, BIO_FLAGS_WRITE | BIO_FLAGS_SHOULD_RETRY);
371             break;
372         case SSL_ERROR_WANT_CONNECT:
373             BIO_set_flags(b, BIO_FLAGS_IO_SPECIAL | BIO_FLAGS_SHOULD_RETRY);
374             BIO_set_retry_reason(b, BIO_get_retry_reason(next));
375             break;
376         case SSL_ERROR_WANT_X509_LOOKUP:
377             BIO_set_retry_special(b);
378             BIO_set_retry_reason(b, BIO_RR_SSL_X509_LOOKUP);
379             break;
380         default:
381             break;
382         }
383         break;
384     case BIO_CTRL_DUP:
385         dbio = (BIO *)ptr;
386         dbs = BIO_get_data(dbio);
387         SSL_free(dbs->ssl);
388         dbs->ssl = SSL_dup(ssl);
389         dbs->num_renegotiates = bs->num_renegotiates;
390         dbs->renegotiate_count = bs->renegotiate_count;
391         dbs->byte_count = bs->byte_count;
392         dbs->renegotiate_timeout = bs->renegotiate_timeout;
393         dbs->last_time = bs->last_time;
394         ret = (dbs->ssl != NULL);
395         break;
396     case BIO_C_GET_FD:
397         ret = BIO_ctrl(ssl->rbio, cmd, num, ptr);
398         break;
399     case BIO_CTRL_SET_CALLBACK:
400         {
401 #if 0                           /* FIXME: Should this be used? -- Richard
402                                  * Levitte */
403             SSLerr(SSL_F_SSL_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
404             ret = -1;
405 #else
406             ret = 0;
407 #endif
408         }
409         break;
410     case BIO_CTRL_GET_CALLBACK:
411         {
412             void (**fptr) (const SSL *xssl, int type, int val);
413
414             fptr = (void (**)(const SSL *xssl, int type, int val))ptr;
415             *fptr = SSL_get_info_callback(ssl);
416         }
417         break;
418     default:
419         ret = BIO_ctrl(ssl->rbio, cmd, num, ptr);
420         break;
421     }
422     return (ret);
423 }
424
425 static long ssl_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
426 {
427     SSL *ssl;
428     BIO_SSL *bs;
429     long ret = 1;
430
431     bs = BIO_get_data(b);
432     ssl = bs->ssl;
433     switch (cmd) {
434     case BIO_CTRL_SET_CALLBACK:
435         {
436             /*
437              * FIXME: setting this via a completely different prototype seems
438              * like a crap idea
439              */
440             SSL_set_info_callback(ssl, (void (*)(const SSL *, int, int))fp);
441         }
442         break;
443     default:
444         ret = BIO_callback_ctrl(ssl->rbio, cmd, fp);
445         break;
446     }
447     return (ret);
448 }
449
450 static int ssl_puts(BIO *bp, const char *str)
451 {
452     int n, ret;
453
454     n = strlen(str);
455     ret = BIO_write(bp, str, n);
456     return (ret);
457 }
458
459 BIO *BIO_new_buffer_ssl_connect(SSL_CTX *ctx)
460 {
461 #ifndef OPENSSL_NO_SOCK
462     BIO *ret = NULL, *buf = NULL, *ssl = NULL;
463
464     if ((buf = BIO_new(BIO_f_buffer())) == NULL)
465         return (NULL);
466     if ((ssl = BIO_new_ssl_connect(ctx)) == NULL)
467         goto err;
468     if ((ret = BIO_push(buf, ssl)) == NULL)
469         goto err;
470     return (ret);
471  err:
472     BIO_free(buf);
473     BIO_free(ssl);
474 #endif
475     return (NULL);
476 }
477
478 BIO *BIO_new_ssl_connect(SSL_CTX *ctx)
479 {
480 #ifndef OPENSSL_NO_SOCK
481     BIO *ret = NULL, *con = NULL, *ssl = NULL;
482
483     if ((con = BIO_new(BIO_s_connect())) == NULL)
484         return (NULL);
485     if ((ssl = BIO_new_ssl(ctx, 1)) == NULL)
486         goto err;
487     if ((ret = BIO_push(ssl, con)) == NULL)
488         goto err;
489     return (ret);
490  err:
491     BIO_free(con);
492 #endif
493     return (NULL);
494 }
495
496 BIO *BIO_new_ssl(SSL_CTX *ctx, int client)
497 {
498     BIO *ret;
499     SSL *ssl;
500
501     if ((ret = BIO_new(BIO_f_ssl())) == NULL)
502         return (NULL);
503     if ((ssl = SSL_new(ctx)) == NULL) {
504         BIO_free(ret);
505         return (NULL);
506     }
507     if (client)
508         SSL_set_connect_state(ssl);
509     else
510         SSL_set_accept_state(ssl);
511
512     BIO_set_ssl(ret, ssl, BIO_CLOSE);
513     return (ret);
514 }
515
516 int BIO_ssl_copy_session_id(BIO *t, BIO *f)
517 {
518     BIO_SSL *tdata, *fdata;
519     t = BIO_find_type(t, BIO_TYPE_SSL);
520     f = BIO_find_type(f, BIO_TYPE_SSL);
521     if ((t == NULL) || (f == NULL))
522         return 0;
523     tdata = BIO_get_data(t);
524     fdata = BIO_get_data(f);
525     if ((tdata->ssl == NULL) || (fdata->ssl == NULL))
526         return (0);
527     if (!SSL_copy_session_id(tdata->ssl, (fdata->ssl)))
528         return 0;
529     return (1);
530 }
531
532 void BIO_ssl_shutdown(BIO *b)
533 {
534     SSL *s;
535
536     b = BIO_find_type(b, BIO_TYPE_SSL);
537     if (b == NULL)
538         return;
539
540     s = BIO_get_data(b);
541     SSL_shutdown(s);
542 }