There has been some confusion on my previous post with Bob Beck of LibreSSL on whether I would advocate for using a LibreSSL shared object as a drop-in replacement for an OpenSSL shared object. Let me state this here, boldly: you should never, ever, for no reason, use shared objects from different major/minor OpenSSL versions or implementations (such as LibreSSL) as a drop-in replacement for one another.
The reason is, obviously, that the ABI of these libraries differs, sometimes subtly enought that they may actually load and run, but then perform abysmally insecure operations, as its data structures will have changed, and now instead of reading your random-generated key, you may be reading the master private key. nd in general, for other libraries you may even be calling the wrong set of functions, especially for those written in C++, where the vtable content may be rearranged across versions.
What I was discussing in the previous post was the fact that lots of proprietary software packages, by bundling a version of Curl that depends on the
RAND_egd() function, will require either unbundling it, or keeping along a copy of OpenSSL to use for runtime linking. And I think that is a problem that people need to consider now rather than later for a very simple reason.
Even if LibreSSL (or any other reimplementation, for what matters) takes foot as the default implementation for all Linux (and not-Linux) distributions, you’ll never be able to fully forget of OpenSSL: not only if you have proprietary software that you maintain, but also because a huge amount of software (and especially hardware) out there will not be able to update easily. And the fact that LibreSSL is throwing away so much of the OpenSSL clutter also means that it’ll be more difficult to backport fixes — while at the same time I think that a good chunk of the black hattery will focus on OpenSSL, especially if it feels “abandoned”, while most of the users will still be using it somehow.
But putting aside the problem of the direct drop-in incompatibilities, there is one more problem that people need to understand, especially Gentoo users, and most other systems that do not completely rebuild their package set when replacing a library like this. The problem is what I would call “ABI leakage”.
Let’s say you have a general
libfoo that uses
libssl; it uses a subset of the API that works with both OpenSSL. Now you have a
bar program that uses
libfoo. If the library is written properly, then it’ll treat all the data structures coming from
libssl as opaque, providing no way for
bar to call into
libssl without depending on the SSL API du jour (and thus putting a direct dependency on
libssl for the executable). But it’s very well possible that
libfoo is not well-written and actually treats the
libssl API as transparent. For instance a common mistake is to use one of the SSL data structures inline (rather than as a pointer) in one of its own public structures.
This situation would be barely fine, as long as the data types for
libfoo are also completely opaque, as then it’s only the code for
libfoo that relies on the structures, and since you’re rebuilding it anyway (as
libssl is not ABI-compatible), you solve your problem. But if we keep assuming a worst-case scenario, then you have
bar actually dealing with the data structures, for instance by allocating a sized buffer itself, rather than calling into a proper allocation function from
libfoo. And there you have a problem.
Because now the ABI of
libfoo is not directly defined by its own code, but also by whichever ABI
libssl has! It’s a similar problem as the symbol table used as an ABI proxy: while your software will load and run (for a while), you’re really using a different ABI, as
libfoo almost certainly does not change its soname when it’s rebuilt against a newer version of
libssl. And that can easily cause crashes and worse (see the note above about dropping in LibreSSL as a replacement for OpenSSL).
Now honestly none of this is specific to LibreSSL. The same is true if you were to try using OpenSSL 1.0 shared objects for software built against OpenSSL 0.9 — which is why I cringed any time I heard people suggesting to use symlink at the time, and it seems like people are giving the same suicidal suggestion now with OpenSSL, according to Bob.
So once again, don’t expect binary-compatibility across different versions of OpenSSL, LibreSSL, or any other implementation of the same API, unless they explicitly aim for that (and LibreSSL definitely doesn’t!)