[openssl-users] DTLS fragmentation and mem BIO

[Alfred E. Heggestad]

On 05/06/15 11:20, Lorenzo Miniero wrote:
> 2015-06-05 10:31 GMT+02:00 Matt Caswell <matt at openssl.org <mailto:matt at openssl.org>>:
>
>
>
>     On 05/06/15 08:09, Lorenzo Miniero wrote:
>      > Hi all,
>      >
>      > first of all, apologies if this has been asked before. I've searched
>      > archives pretty much everywhere, and only came to partial indications as
>      > to how this should be dealt with.
>      >
>      > The problem I'm facing deals with using DTLS with mem BIOs, as I have to
>      > take care of transport myself. Specifically, I've implemented a WebRTC
>      > gateway called Janus, which means all the connectivity related stuff is
>      > delegated to another library (libnice in this case). This mostly works
>      > great (kudos to you guys!), but I have problems as soon as packets
>      > exceed the MTU, which can easily happen whenever, for instance, you try
>      > to handshake with certificates larger than 1024 bits. I read around that
>      > the DTLS stack in OpenSSL automatically deals with this, and in fact
>      > this seems to be happening: what isn't working is the BIO mem part of this.
>      >
>      > More specifically, OpenSSL does indeed take care of fragmenting the
>      > packets according to what is assumed to be the MTU (1472 by default, or
>      > the value as set in s->d1->mtu). The problem is that the mem BIO ignores
>      > that fragmentation info completely, and so, when you do an BIO_read,
>      > makes available at the application the whole packet anyway. This results
>      > in the whole buffer being passed to nice_agent_send (the method libnice
>      > exposes to send packets), which means it's just as not fragmenting
>      > anything: the packet is too large and the network drops it. You can
>      > verify this by using, e.g., a 4096 bits certificate, and capture the
>      > DTLS traffic with Wireshark: you'll see that the message is recognized
>      > as composed of not only multiple messages, but also fragments.
>      >
>      > Is there any way I can force the BIO to return the invididual
>      > fragments/messages when I do a BIO_read, so that I can send properly
>      > sized packets? I've tried looking around but found no insight on how to
>      > do that. The only approach that came to my mind was to manually inspect
>      > the buffer that is returned, and split messages/fragments myself, but
>      > I'd rather avoid delving within the specifics of the protocol if possible.
>      >
>      > Thanks in advance for any help you may provide me with!
>
>     Hmmmm. An interesting problem.
>
>     The issue is that a mem BIO has no knowledge of datagram semantics
>     (perhaps we need to add something for OpenSSL 1.1.0).
>
>     In a dgram BIO each BIO_write translates to a single datagram being
>     produced. In a mem BIO you just have a big bucket of memory, and every
>     time you get a BIO_write you just add the data onto the end of
>     everything that we've go so far, and so the packet boundaries are not
>     respected.
>
>     How about you create a custom filter BIO? All it would need to do is
>     proxy all calls down to the underlying mem BIO. Along the way though it
>     could take note of where the packet boundaries are, so when you call
>     BIO_read it only gives it to you a datagram at a time.
>
>     Matt
>
>
>
> Thanks for the very quick answer!
>
> Your suggestion does indeed make much more sense that manually inspecting the buffer as I thought of, as you don't need to know anything about the protocol but
> only to be ready to index the packets you see passing by. I never tried writing a BIO filter but there's a first time for everything :-)
>
> Just one quick question about this: are messages/packets passed to the BIO actually splitted, and then just queued by the mem BIO in the buffer, or can there be
> cases where a larger than normal buffer is passed to the BIO anyway, meaning a manual splitting could be needed nevertheless from time to time?
>


hey,


I just want to point out that we have been using OpenSSL in the libre stack for
a long time, with successful deployment.


the DTLS code is here:

http://www.creytiv.com/doxygen/re-dox/html/tls__udp_8c_source.html


we are using 2 different BIOs; one for outgoing, one for incoming:



	tc->sbio_in = BIO_new(BIO_s_mem());
	if (!tc->sbio_in) {
		ERR_clear_error();
		err = ENOMEM;
		goto out;
	}

	tc->sbio_out = BIO_new(&bio_udp_send);
	if (!tc->sbio_out) {
		ERR_clear_error();
		BIO_free(tc->sbio_in);
		err = ENOMEM;
		goto out;
	}





/alfred