akashicyitai/cve-2019-6250-libzmqExploit de prueba de concepto dedicado para CVE-2019-6250 en libzmq, que utiliza un desbordamiento de enteros para sobrescribir un puntero de función y lograr la ejecución remota de código mediante mensajes ZMTP manipulados.
ZeroMQ (ZMQ) es una librería de mensajería asíncrona de alto rendimiento diseñada para proporcionar un mecanismo de paso de mensajes eficiente y flexible en entornos de computación distribuida o paralela. ZeroMQ ofrece varios patrones de mensajería (como solicitud-respuesta, publicación-suscripción, push-pull, proxy, etc.) y soporta múltiples protocolos de transporte (como TCP, IPC, PGM, etc.). Su objetivo es simplificar la programación en red y mejorar el rendimiento mediante colas de mensajes eficientes.
libzmq es la implementación principal de la librería ZeroMQ, generalmente referida como la implementación en C de la librería ZeroMQ. Es la materialización concreta de las funcionalidades de ZeroMQ, proporcionando soporte base para varios lenguajes de programación. libzmq ofrece todas las funcionalidades centrales de ZeroMQ y puede utilizarse junto con múltiples enlaces de lenguaje.
Descargar la librería libzmq
git clone https://github.com/zeromq/libzmq.git
cd libzmq
git reset --hard 7302b9b8d127be5aa1f1ccebb9d01df0800182f3
El autor ya ha corregido esta vulnerabilidad. Para reproducirla, acceda a src/v2_decoder.cpp y modifique el contenido de la función zmq::v2_decoder_t::size_ready con el siguiente código:
int zmq::v2_decoder_t::size_ready (uint64_t msg_size_,unsigned char const *read_pos_)
{
int rc = _in_progress.close ();
assert (rc == 0);
// the current message can exceed the current buffer. We have to copy the buffer
// data into a new message and complete it in the next receive.
shared_message_memory_allocator &allocator = get_allocator ();
if (unlikely (!_zero_copy
|| ((unsigned char *) read_pos_ + msg_size_
> (allocator.data () + allocator.size ())))) {
// a new message has started, but the size would exceed the pre-allocated arena
// this happens every time when a message does not fit completely into the buffer
rc = _in_progress.init_size (static_cast<size_t> (msg_size_));
} else {
// construct message using n bytes from the buffer as storage
// increase buffer ref count
// if the message will be a large message, pass a valid refcnt memory location as well
rc =
_in_progress.init (const_cast<unsigned char *> (read_pos_),
static_cast<size_t> (msg_size_),
shared_message_memory_allocator::call_dec_ref,
allocator.buffer (), allocator.provide_content ());
// For small messages, data has been copied and refcount does not have to be increased
if (_in_progress.is_zcmsg ()) {
allocator.advance_content ();
allocator.inc_ref ();
}
}
if (unlikely (rc)) {
errno_assert (errno == ENOMEM);
rc = _in_progress.init ();
errno_assert (rc == 0);
errno = ENOMEM;
return -1;
}
_in_progress.set_flags (_msg_flags);
// this sets read_pos to
// the message data address if the data needs to be copied
// for small message / messages exceeding the current buffer
// or
// to the current start address in the buffer because the message
// was constructed to use n bytes from the address passed as argument
next_step (_in_progress.data (), _in_progress.size (),
&v2_decoder_t::message_ready);
return 0;
}
Instalar la librería libzmq
sudo apt-get install libtool pkg-config build-essential autoconf
automake
./autogen.sh
./configure
make
sudo make install
Descargar e instalar cppzmq
git clone https://github.com/zeromq/cppzmq
cd cppzmq
cmake .
sudo make -j4 install
Reemplace /demo/main.cpp con el main.cpp de este repositorio.
Compilar main.cpp
cd demo
mkdir build
cd build
cmake ..
make
./demo
En Libzmq/src/v2_decoder.cpp, el siguiente contenido presenta un desbordamiento de enteros. Cuando el valor de msg_size_ es muy grande, read_pos + msg_size_ resulta ser un número muy pequeño, por lo que la condición if se evalúa como falsa y el programa no inicializa el tamaño del mensaje.
if (unlikely (!_zero_copy
|| ((unsigned char *) read_pos_ + msg_size_
> (allocator.data () + allocator.size ())))) {
Por lo tanto, se puede sobrescribir la memoria posterior al búfer con el mensaje escrito. La memoria posterior al búfer corresponde a una estructura content_t, que contiene un puntero a función ffn y los parámetros data y hint.
67 struct content_t 68 { 69 void *data; 70 size_t size; 71 msg_free_fn *ffn; 72 void *hint; 73 zmq::atomic_counter_t refcnt; 74 };
Controlando el mensaje transmitido, se pueden sobrescribir el puntero a función y sus parámetros con funciones y argumentos específicos para lograr el ataque.