CVE-2019-6250-libzmq

ZeroMQ (ZMQ)

ZeroMQ (ZMQ) é uma biblioteca de mensagens assíncronas de alto desempenho, projetada para fornecer um mecanismo de troca de mensagens eficiente e flexível em ambientes de computação distribuída ou paralela. O ZeroMQ oferece diversos padrões de troca de mensagens (como requisição-resposta, publicação-assinatura, push-pull, proxy, etc.) e suporta múltiplos protocolos de transporte (como TCP, IPC, PGM, etc.). O objetivo de design do ZeroMQ é simplificar a programação de rede e melhorar o desempenho por meio de filas de mensagens eficientes.

libzmq

libzmq é a biblioteca de implementação central do ZeroMQ, geralmente referindo-se à implementação em C da biblioteca ZeroMQ. Ela é a concretização das funcionalidades do ZeroMQ, fornecendo suporte básico para várias linguagens de programação. A libzmq oferece todas as funcionalidades principais do ZeroMQ e pode ser utilizada com diversas ligações de linguagens.

Método de ataque

Baixar a biblioteca libzmq

git clone https://github.com/zeromq/libzmq.git
cd libzmq
git reset --hard 7302b9b8d127be5aa1f1ccebb9d01df0800182f3

O autor já corrigiu a vulnerabilidade. Vá para src/v2_decoder.cpp e modifique o conteúdo da função zmq::v2_decoder_t::size_ready para o código abaixo, a fim de reproduzir a vulnerabilidade:

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 a biblioteca libzmq

sudo apt-get install libtool pkg-config build-essential autoconf
automake
./autogen.sh
./configure
make
sudo make install

Baixar e instalar cppzmq

git clone https://github.com/zeromq/cppzmq
cd cppzmq
cmake .
sudo make -j4 install

Substituir /demo/main.cpp pelo main.cpp neste repositório

Compilar main.cpp

cd demo
mkdir build
cd build
cmake ..
make
./demo

Localização da vulnerabilidade

O conteúdo a seguir em Libzmq/src/v2_decoder.cpp apresenta um estouro de inteiro. Quando o valor de msg_size_ é muito grande, read_pos+msg_size_ acaba sendo um número muito pequeno, fazendo com que a condição if seja falsa e o programa não inicialize o tamanho da mensagem. if (unlikely (!zero_copy || ((unsigned char *) read_pos + msg_size_ > (allocator.data () + allocator.size ())))) {

Portanto, é possível sobrescrever a memória após o buffer utilizando a mensagem escrita. A memória após o buffer contém uma estrutura content_t, que inclui um ponteiro de função ffn e seus parâmetros data e 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 };

Exploração da vulnerabilidade

Ao controlar a mensagem transmitida, é possível sobrescrever o ponteiro de função e os parâmetros acima com funções e argumentos específicos, realizando assim o ataque.