Почему этот код уязвим для атак переполнения буфера?

int func(char* str)
{
   char buffer[100];
   unsigned short len = strlen(str);

   if(len >= 100)
   {
        return (-1);
   }

   strncpy(buffer,str,strlen(str));
   return 0;
}

Этот код уязвим для атаки переполнения буфера, и я пытаюсь выяснить, почему. Я думаю, что это связано с lenтем, чтобы быть объявленным shortвместо int, но я не совсем уверен.

Любые идеи?

На большинстве компиляторов максимальное значение unsigned shortравно 65535.

Любое значение выше этого оборачивается, поэтому 65536 становится 0, а 65600 становится 65.

Это означает, что длинные строки правильной длины (например, 65600) пройдут проверку и переполнят буфер.

Используйте size_tдля хранения результата strlen(), а не для unsigned shortсравнения lenс выражением, которое непосредственно кодирует размер buffer. Так, например:

char buffer[100];
size_t len = strlen(str);
if (len >= sizeof(buffer) / sizeof(buffer[0]))  return -1;
memcpy(buffer, str, len + 1);

Проблема здесь:

strncpy(buffer,str,strlen(str));
                   ^^^^^^^^^^^

Если строка превышает длину целевого буфера, strncpy все равно скопирует ее. Вы основываете количество символов строки в качестве числа для копирования вместо размера буфера. Правильный способ сделать это заключается в следующем:

strncpy(buffer,str, sizeof(buff) - 1);
buffer[sizeof(buff) - 1] = '\0';

Это ограничивает объем копируемых данных фактическим размером буфера минус один для нулевого завершающего символа. Затем мы устанавливаем последний байт в буфере нулевым символом в качестве дополнительной защиты. Причина этого в том, что strncpy будет копировать до n байтов, включая завершающий ноль, если strlen (str) <len - 1. Если нет, то ноль не копируется, и у вас есть сценарий сбоя, потому что теперь ваш буфер имеет неопределенный строка.

Надеюсь это поможет.

РЕДАКТИРОВАТЬ: После дальнейшего изучения и ввода от других, возможное кодирование для функции следующим образом:

int func (char *str)
  {
    char buffer[100];
    unsigned short size = sizeof(buffer);
    unsigned short len = strlen(str);

    if (len > size - 1) return(-1);
    memcpy(buffer, str, len + 1);
    buffer[size - 1] = '\0';
    return(0);
  }

Поскольку мы уже знаем длину строки, мы можем использовать memcpy, чтобы скопировать строку из местоположения, на которое ссылается str, в буфер. Обратите внимание, что на странице руководства для strlen (3) (в системе FreeBSD 9.3) указано следующее:

 The strlen() function returns the number of characters that precede the
 terminating NUL character.  The strnlen() function returns either the
 same result as strlen() or maxlen, whichever is smaller.

Который я интерпретирую как то, что длина строки не включает ноль. Вот почему я копирую len + 1 байт, чтобы включить ноль, и тест проверяет, чтобы убедиться, что длина <размер буфера - 2. Минус один, потому что буфер начинается с позиции 0, и минус другой, чтобы убедиться, что есть место для нуля.

РЕДАКТИРОВАТЬ: Оказывается, размер чего-то начинается с 1, а доступ начинается с 0, так что -2 раньше был неправильным, потому что он вернул бы ошибку для всего> 98 байтов, но это должно быть> 99 байтов.

РЕДАКТИРОВАТЬ: Хотя ответ о беззнаковых коротких, как правило, является правильным, так как максимальная длина, которая может быть представлена, составляет 65 535 символов, это на самом деле не имеет значения, потому что если строка длиннее, значение будет перенесено. Это все равно, что взять 75 231 (что 0x000125DF) и замаскировать верхние 16 бит, что даст вам 9695 (0x000025DF). Единственная проблема, с которой я сталкиваюсь, это первые 100 символов после 65 535, поскольку проверка длины разрешит копирование, но во всех случаях будет копироваться только до первых 100 символов строки, и нулевое завершение строки . Таким образом, даже в случае проблемы с переносом, буфер все равно не будет переполнен.

Это может или не может само по себе представлять угрозу безопасности в зависимости от содержимого строки и того, для чего вы ее используете. Если это просто прямой текст, который читается человеком, то обычно проблем нет. Вы просто получаете усеченную строку. Однако, если это что-то вроде URL или даже последовательности команд SQL, у вас могут возникнуть проблемы.

Даже если вы используете strncpy, длина обрезки по-прежнему зависит от переданного указателя строки. Вы не представляете, какой длины эта строка (то есть расположение нулевого терминатора относительно указателя). Таким образом, strlenодин только вызов открывает вам уязвимость. Если вы хотите быть более безопасным, используйте strnlen(str, 100).

Полный исправленный код будет:

int func(char *str) {
   char buffer[100];
   unsigned short len = strnlen(str, 100); // sizeof buffer

   if (len >= 100) {
     return -1;
   }

   strcpy(buffer, str); // this is safe since null terminator is less than 100th index
   return 0;
}

Ответ с упаковкой правильный. Но есть проблема, я думаю, не была упомянута, если (len> = 100)

Ну, если бы Len был 100, мы скопировали бы 100 элементов, и у нас не было бы трейлинга \ 0. Это явно означало бы, что любая другая функция, зависящая от правильной завершенной строки, будет выходить далеко за пределы исходного массива.

ИМХО неразрешимая строка из C является ИМХО. Тебе лучше иметь некоторые ограничения до звонка, но даже это не поможет. Проверка границ отсутствует, поэтому переполнение буфера всегда возможно и, к сожалению, произойдет ....

Помимо проблем безопасности, связанных с вызовом strlenболее одного раза, обычно не следует использовать строковые методы для строк, длина которых точно известна [для большинства строковых функций существует только очень узкий случай, когда их следует использовать - для строк, для которых максимум длина может быть гарантирована, но точная длина не известна]. Как только длина входной строки известна, а длина выходного буфера известна, следует выяснить, насколько большой регион должен быть скопирован, а затем использовать его memcpy()для фактического выполнения рассматриваемого копирования. Хотя возможно, что это strcpyможет быть лучше, чем memcpy()при копировании строки длиной всего 1-3 байта, на многих платформах memcpy(), вероятно, будет более чем в два раза быстрее при работе с большими строками.

Несмотря на то, что в некоторых ситуациях безопасность достигается за счет производительности, в такой ситуации безопасный подход также является более быстрым. В некоторых случаях может быть разумным написать код, который не защищен от вводов странного поведения, если код, предоставляющий входы, может гарантировать, что они будут вести себя хорошо, и если защита от вводов плохого поведения может снизить производительность. Проверка того, что длины строк проверяются только один раз, повышает как производительность, так и безопасность, хотя можно сделать еще одну вещь для обеспечения безопасности даже при отслеживании длины строки вручную: для каждой строки, которая, как ожидается, будет иметь конечный ноль, пишите конечный ноль явно чем ожидание исходной строки, чтобы иметь его. Таким образом, если бы вы писали strdupэквивалент:

char *strdupe(char const *src)
{
  size_t len = strlen(src);
  char *dest = malloc(len+1);
  // Calculation can't wrap if string is in valid-size memory block
  if (!dest) return (OUT_OF_MEMORY(),(char*)0); 
  // OUT_OF_MEMORY is expected to halt; the return guards if it doesn't
  memcpy(dest, src, len);      
  dest[len]=0;
  return dest;
}

Обратите внимание, что последний оператор, как правило, может быть опущен, если memcpy обработал len+1байты, но если другой поток должен был изменить исходную строку, результатом может быть строка назначения, не оканчивающаяся NUL.