tls: Use custom IO to read from the URLContext
[ffmpeg.git] / libavformat / tls.c
1 /*
2  * TLS/SSL Protocol
3  * Copyright (c) 2011 Martin Storsjo
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include "avformat.h"
23 #include "url.h"
24 #include "libavutil/avstring.h"
25 #include "libavutil/opt.h"
26 #include "libavutil/parseutils.h"
27 #if CONFIG_GNUTLS
28 #include <gnutls/gnutls.h>
29 #include <gnutls/x509.h>
30 #define TLS_read(c, buf, size)  gnutls_record_recv(c->session, buf, size)
31 #define TLS_write(c, buf, size) gnutls_record_send(c->session, buf, size)
32 #define TLS_shutdown(c)         gnutls_bye(c->session, GNUTLS_SHUT_RDWR)
33 #define TLS_free(c) do { \
34         if (c->session) \
35             gnutls_deinit(c->session); \
36         if (c->cred) \
37             gnutls_certificate_free_credentials(c->cred); \
38     } while (0)
39
40 static ssize_t gnutls_url_pull(gnutls_transport_ptr_t transport,
41                                void *buf, size_t len)
42 {
43     URLContext *h = (URLContext*) transport;
44     int ret = ffurl_read(h, buf, len);
45     if (ret >= 0)
46         return ret;
47     if (ret == AVERROR(EAGAIN))
48         errno = EAGAIN;
49     else
50         errno = EIO;
51     return -1;
52 }
53 static ssize_t gnutls_url_push(gnutls_transport_ptr_t transport,
54                                const void *buf, size_t len)
55 {
56     URLContext *h = (URLContext*) transport;
57     int ret = ffurl_write(h, buf, len);
58     if (ret >= 0)
59         return ret;
60     if (ret == AVERROR(EAGAIN))
61         errno = EAGAIN;
62     else
63         errno = EIO;
64     return -1;
65 }
66 #elif CONFIG_OPENSSL
67 #include <openssl/bio.h>
68 #include <openssl/ssl.h>
69 #include <openssl/err.h>
70 #define TLS_read(c, buf, size)  SSL_read(c->ssl,  buf, size)
71 #define TLS_write(c, buf, size) SSL_write(c->ssl, buf, size)
72 #define TLS_shutdown(c)         SSL_shutdown(c->ssl)
73 #define TLS_free(c) do { \
74         if (c->ssl) \
75             SSL_free(c->ssl); \
76         if (c->ctx) \
77             SSL_CTX_free(c->ctx); \
78     } while (0)
79
80 static int url_bio_create(BIO *b)
81 {
82     b->init = 1;
83     b->ptr = NULL;
84     b->flags = 0;
85     return 1;
86 }
87
88 static int url_bio_destroy(BIO *b)
89 {
90     return 1;
91 }
92
93 static int url_bio_bread(BIO *b, char *buf, int len)
94 {
95     URLContext *h = b->ptr;
96     int ret = ffurl_read(h, buf, len);
97     if (ret >= 0)
98         return ret;
99     BIO_clear_retry_flags(b);
100     if (ret == AVERROR(EAGAIN))
101         BIO_set_retry_read(b);
102     return -1;
103 }
104
105 static int url_bio_bwrite(BIO *b, const char *buf, int len)
106 {
107     URLContext *h = b->ptr;
108     int ret = ffurl_write(h, buf, len);
109     if (ret >= 0)
110         return ret;
111     BIO_clear_retry_flags(b);
112     if (ret == AVERROR(EAGAIN))
113         BIO_set_retry_write(b);
114     return -1;
115 }
116
117 static long url_bio_ctrl(BIO *b, int cmd, long num, void *ptr)
118 {
119     if (cmd == BIO_CTRL_FLUSH) {
120         BIO_clear_retry_flags(b);
121         return 1;
122     }
123     return 0;
124 }
125
126 static int url_bio_bputs(BIO *b, const char *str)
127 {
128     return url_bio_bwrite(b, str, strlen(str));
129 }
130
131 static BIO_METHOD url_bio_method = {
132     .type = BIO_TYPE_SOURCE_SINK,
133     .name = "urlprotocol bio",
134     .bwrite = url_bio_bwrite,
135     .bread = url_bio_bread,
136     .bputs = url_bio_bputs,
137     .bgets = NULL,
138     .ctrl = url_bio_ctrl,
139     .create = url_bio_create,
140     .destroy = url_bio_destroy,
141 };
142
143 #endif
144 #include "network.h"
145 #include "os_support.h"
146 #include "internal.h"
147 #if HAVE_POLL_H
148 #include <poll.h>
149 #endif
150
151 typedef struct TLSContext {
152     const AVClass *class;
153     URLContext *tcp;
154 #if CONFIG_GNUTLS
155     gnutls_session_t session;
156     gnutls_certificate_credentials_t cred;
157 #elif CONFIG_OPENSSL
158     SSL_CTX *ctx;
159     SSL *ssl;
160 #endif
161     int fd;
162     char *ca_file;
163     int verify;
164     char *cert_file;
165     char *key_file;
166     int listen;
167 } TLSContext;
168
169 #define OFFSET(x) offsetof(TLSContext, x)
170 #define D AV_OPT_FLAG_DECODING_PARAM
171 #define E AV_OPT_FLAG_ENCODING_PARAM
172 static const AVOption options[] = {
173     {"ca_file",    "Certificate Authority database file", OFFSET(ca_file),   AV_OPT_TYPE_STRING, .flags = D|E },
174     {"tls_verify", "Verify the peer certificate",         OFFSET(verify),    AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, .flags = D|E },
175     {"cert_file",  "Certificate file",                    OFFSET(cert_file), AV_OPT_TYPE_STRING, .flags = D|E },
176     {"key_file",   "Private key file",                    OFFSET(key_file),  AV_OPT_TYPE_STRING, .flags = D|E },
177     {"listen",     "Listen for incoming connections",     OFFSET(listen),    AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, .flags = D|E },
178     { NULL }
179 };
180
181 static const AVClass tls_class = {
182     .class_name = "tls",
183     .item_name  = av_default_item_name,
184     .option     = options,
185     .version    = LIBAVUTIL_VERSION_INT,
186 };
187
188 static int do_tls_poll(URLContext *h, int ret)
189 {
190     TLSContext *c = h->priv_data;
191     struct pollfd p = { c->fd, 0, 0 };
192 #if CONFIG_GNUTLS
193     switch (ret) {
194     case GNUTLS_E_AGAIN:
195     case GNUTLS_E_INTERRUPTED:
196         break;
197     case GNUTLS_E_WARNING_ALERT_RECEIVED:
198         av_log(h, AV_LOG_WARNING, "%s\n", gnutls_strerror(ret));
199         break;
200     default:
201         av_log(h, AV_LOG_ERROR, "%s\n", gnutls_strerror(ret));
202         return AVERROR(EIO);
203     }
204     if (gnutls_record_get_direction(c->session))
205         p.events = POLLOUT;
206     else
207         p.events = POLLIN;
208 #elif CONFIG_OPENSSL
209     ret = SSL_get_error(c->ssl, ret);
210     if (ret == SSL_ERROR_WANT_READ) {
211         p.events = POLLIN;
212     } else if (ret == SSL_ERROR_WANT_WRITE) {
213         p.events = POLLOUT;
214     } else {
215         av_log(h, AV_LOG_ERROR, "%s\n", ERR_error_string(ERR_get_error(), NULL));
216         return AVERROR(EIO);
217     }
218 #endif
219     if (h->flags & AVIO_FLAG_NONBLOCK)
220         return AVERROR(EAGAIN);
221     while (1) {
222         int n = poll(&p, 1, 100);
223         if (n > 0)
224             break;
225         if (ff_check_interrupt(&h->interrupt_callback))
226             return AVERROR(EINTR);
227     }
228     return 0;
229 }
230
231 static int tls_open(URLContext *h, const char *uri, int flags, AVDictionary **options)
232 {
233     TLSContext *c = h->priv_data;
234     int ret;
235     int port;
236     const char *p;
237     char buf[200], host[200], opts[50] = "";
238     int numerichost = 0;
239     struct addrinfo hints = { 0 }, *ai = NULL;
240     const char *proxy_path;
241     int use_proxy;
242 #if CONFIG_OPENSSL
243     BIO *bio;
244 #endif
245
246     ff_tls_init();
247
248     if (c->listen)
249         snprintf(opts, sizeof(opts), "?listen=1");
250
251     av_url_split(NULL, 0, NULL, 0, host, sizeof(host), &port, NULL, 0, uri);
252
253     p = strchr(uri, '?');
254
255     if (!p) {
256         p = opts;
257     } else {
258         if (av_find_info_tag(opts, sizeof(opts), "listen", p))
259             c->listen = 1;
260     }
261
262     ff_url_join(buf, sizeof(buf), "tcp", NULL, host, port, "%s", p);
263
264     hints.ai_flags = AI_NUMERICHOST;
265     if (!getaddrinfo(host, NULL, &hints, &ai)) {
266         numerichost = 1;
267         freeaddrinfo(ai);
268     }
269
270     proxy_path = getenv("http_proxy");
271     use_proxy = !ff_http_match_no_proxy(getenv("no_proxy"), host) &&
272                 proxy_path && av_strstart(proxy_path, "http://", NULL);
273
274     if (use_proxy) {
275         char proxy_host[200], proxy_auth[200], dest[200];
276         int proxy_port;
277         av_url_split(NULL, 0, proxy_auth, sizeof(proxy_auth),
278                      proxy_host, sizeof(proxy_host), &proxy_port, NULL, 0,
279                      proxy_path);
280         ff_url_join(dest, sizeof(dest), NULL, NULL, host, port, NULL);
281         ff_url_join(buf, sizeof(buf), "httpproxy", proxy_auth, proxy_host,
282                     proxy_port, "/%s", dest);
283     }
284
285     ret = ffurl_open(&c->tcp, buf, AVIO_FLAG_READ_WRITE,
286                      &h->interrupt_callback, options);
287     if (ret)
288         goto fail;
289     c->fd = ffurl_get_file_handle(c->tcp);
290
291 #if CONFIG_GNUTLS
292     gnutls_init(&c->session, c->listen ? GNUTLS_SERVER : GNUTLS_CLIENT);
293     if (!c->listen && !numerichost)
294         gnutls_server_name_set(c->session, GNUTLS_NAME_DNS, host, strlen(host));
295     gnutls_certificate_allocate_credentials(&c->cred);
296     if (c->ca_file)
297         gnutls_certificate_set_x509_trust_file(c->cred, c->ca_file, GNUTLS_X509_FMT_PEM);
298 #if GNUTLS_VERSION_MAJOR >= 3
299     else
300         gnutls_certificate_set_x509_system_trust(c->cred);
301 #endif
302     gnutls_certificate_set_verify_flags(c->cred, c->verify ?
303                                         GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT : 0);
304     if (c->cert_file && c->key_file) {
305         ret = gnutls_certificate_set_x509_key_file(c->cred,
306                                                    c->cert_file, c->key_file,
307                                                    GNUTLS_X509_FMT_PEM);
308         if (ret < 0) {
309             av_log(h, AV_LOG_ERROR,
310                    "Unable to set cert/key files %s and %s: %s\n",
311                    c->cert_file, c->key_file, gnutls_strerror(ret));
312             ret = AVERROR(EIO);
313             goto fail;
314         }
315     }
316     gnutls_credentials_set(c->session, GNUTLS_CRD_CERTIFICATE, c->cred);
317     c->tcp->flags |= AVIO_FLAG_NONBLOCK;
318     gnutls_transport_set_pull_function(c->session, gnutls_url_pull);
319     gnutls_transport_set_push_function(c->session, gnutls_url_push);
320     gnutls_transport_set_ptr(c->session, c->tcp);
321     gnutls_priority_set_direct(c->session, "NORMAL", NULL);
322     while (1) {
323         ret = gnutls_handshake(c->session);
324         if (ret == 0)
325             break;
326         if ((ret = do_tls_poll(h, ret)) < 0)
327             goto fail;
328     }
329     if (c->verify) {
330         unsigned int status, cert_list_size;
331         gnutls_x509_crt_t cert;
332         const gnutls_datum_t *cert_list;
333         if ((ret = gnutls_certificate_verify_peers2(c->session, &status)) < 0) {
334             av_log(h, AV_LOG_ERROR, "Unable to verify peer certificate: %s\n",
335                                     gnutls_strerror(ret));
336             ret = AVERROR(EIO);
337             goto fail;
338         }
339         if (status & GNUTLS_CERT_INVALID) {
340             av_log(h, AV_LOG_ERROR, "Peer certificate failed verification\n");
341             ret = AVERROR(EIO);
342             goto fail;
343         }
344         if (gnutls_certificate_type_get(c->session) != GNUTLS_CRT_X509) {
345             av_log(h, AV_LOG_ERROR, "Unsupported certificate type\n");
346             ret = AVERROR(EIO);
347             goto fail;
348         }
349         gnutls_x509_crt_init(&cert);
350         cert_list = gnutls_certificate_get_peers(c->session, &cert_list_size);
351         gnutls_x509_crt_import(cert, cert_list, GNUTLS_X509_FMT_DER);
352         ret = gnutls_x509_crt_check_hostname(cert, host);
353         gnutls_x509_crt_deinit(cert);
354         if (!ret) {
355             av_log(h, AV_LOG_ERROR,
356                    "The certificate's owner does not match hostname %s\n", host);
357             ret = AVERROR(EIO);
358             goto fail;
359         }
360     }
361 #elif CONFIG_OPENSSL
362     c->ctx = SSL_CTX_new(c->listen ? TLSv1_server_method() : TLSv1_client_method());
363     if (!c->ctx) {
364         av_log(h, AV_LOG_ERROR, "%s\n", ERR_error_string(ERR_get_error(), NULL));
365         ret = AVERROR(EIO);
366         goto fail;
367     }
368     if (c->ca_file)
369         SSL_CTX_load_verify_locations(c->ctx, c->ca_file, NULL);
370     if (c->cert_file && !SSL_CTX_use_certificate_chain_file(c->ctx, c->cert_file)) {
371         av_log(h, AV_LOG_ERROR, "Unable to load cert file %s: %s\n",
372                c->cert_file, ERR_error_string(ERR_get_error(), NULL));
373         ret = AVERROR(EIO);
374         goto fail;
375     }
376     if (c->key_file && !SSL_CTX_use_PrivateKey_file(c->ctx, c->key_file, SSL_FILETYPE_PEM)) {
377         av_log(h, AV_LOG_ERROR, "Unable to load key file %s: %s\n",
378                c->key_file, ERR_error_string(ERR_get_error(), NULL));
379         ret = AVERROR(EIO);
380         goto fail;
381     }
382     // Note, this doesn't check that the peer certificate actually matches
383     // the requested hostname.
384     if (c->verify)
385         SSL_CTX_set_verify(c->ctx, SSL_VERIFY_PEER, NULL);
386     c->ssl = SSL_new(c->ctx);
387     if (!c->ssl) {
388         av_log(h, AV_LOG_ERROR, "%s\n", ERR_error_string(ERR_get_error(), NULL));
389         ret = AVERROR(EIO);
390         goto fail;
391     }
392     bio = BIO_new(&url_bio_method);
393     c->tcp->flags |= AVIO_FLAG_NONBLOCK;
394     bio->ptr = c->tcp;
395     SSL_set_bio(c->ssl, bio, bio);
396     if (!c->listen && !numerichost)
397         SSL_set_tlsext_host_name(c->ssl, host);
398     while (1) {
399         ret = c->listen ? SSL_accept(c->ssl) : SSL_connect(c->ssl);
400         if (ret > 0)
401             break;
402         if (ret == 0) {
403             av_log(h, AV_LOG_ERROR, "Unable to negotiate TLS/SSL session\n");
404             ret = AVERROR(EIO);
405             goto fail;
406         }
407         if ((ret = do_tls_poll(h, ret)) < 0)
408             goto fail;
409     }
410 #endif
411     return 0;
412 fail:
413     TLS_free(c);
414     if (c->tcp)
415         ffurl_close(c->tcp);
416     ff_tls_deinit();
417     return ret;
418 }
419
420 static int tls_read(URLContext *h, uint8_t *buf, int size)
421 {
422     TLSContext *c = h->priv_data;
423     while (1) {
424         int ret = TLS_read(c, buf, size);
425         if (ret > 0)
426             return ret;
427         if (ret == 0)
428             return AVERROR_EOF;
429         if ((ret = do_tls_poll(h, ret)) < 0)
430             return ret;
431     }
432     return 0;
433 }
434
435 static int tls_write(URLContext *h, const uint8_t *buf, int size)
436 {
437     TLSContext *c = h->priv_data;
438     while (1) {
439         int ret = TLS_write(c, buf, size);
440         if (ret > 0)
441             return ret;
442         if (ret == 0)
443             return AVERROR_EOF;
444         if ((ret = do_tls_poll(h, ret)) < 0)
445             return ret;
446     }
447     return 0;
448 }
449
450 static int tls_close(URLContext *h)
451 {
452     TLSContext *c = h->priv_data;
453     TLS_shutdown(c);
454     TLS_free(c);
455     ffurl_close(c->tcp);
456     ff_tls_deinit();
457     return 0;
458 }
459
460 URLProtocol ff_tls_protocol = {
461     .name           = "tls",
462     .url_open2      = tls_open,
463     .url_read       = tls_read,
464     .url_write      = tls_write,
465     .url_close      = tls_close,
466     .priv_data_size = sizeof(TLSContext),
467     .flags          = URL_PROTOCOL_FLAG_NETWORK,
468     .priv_data_class = &tls_class,
469 };