Чому цей код вразливий до атак переповнення буфера?

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, але я не дуже впевнений.

Будь-які ідеї?

Для більшості компіляторів максимальне значення an 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 байтів, включаючи закінчуючий null, якщо strlen (str) <len - 1. Якщо ні, то null не скопіюється, і у вас є сценарій збою, тому що тепер у вашому буфері немає невиконаного рядок.

Сподіваюся, це допомагає.

EDIT: Після подальшого вивчення та введення даних від інших можливе кодування функції:

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, а мінус ще один, щоб переконатися, що є місце для нуля.

EDIT: Виявляється, розмір чогось починається з 1, а доступ починається з 0, тому -2 раніше був неправильним, оскільки він повертав би помилку за що-небудь> 98 байт, але він повинен бути> 99 байт.

EDIT: Хоча відповідь про неподписаний короткий, як правило, правильна, оскільки максимальна довжина, яку можна представити, становить 65 555 символів, це насправді не має значення, оскільки якщо рядок довший за це, значення буде обгортатися. Це як взяти 75,231 (що становить 0x000125DF) і замаскувати 16 кращих бітів, що дає 9695 (0x000025DF). Єдиною проблемою, яку я бачу в цьому, є перші 100 знаків минулого 65535, оскільки перевірка довжини дозволить копіювати, але вона копіюватиме лише до перших 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)

Добре, якщо Лен буде 100, ми б скопіювали 100 елементів, у нас не було б слідів \ 0. Це однозначно означало б, що будь-яка інша функція залежно від належного закінченого рядка пішла б за вихідний масив.

Рядок, проблемний з C, є IMHO нерозв'язним. Ви завжди завжди матимете певні обмеження перед викликом, але навіть це не допоможе. Немає перевірки меж, тому переповнення буфера завжди може, і на жаль, станеться ....

Крім проблем із безпекою, пов'язаних із викликом 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.