Чому strncpy не закінчує null?

strncpy()нібито захищає від переповнення буфера. Але якщо це запобігає переповненню без нульового закінчення, швидше за все, наступна операція рядка буде переповнена. Тож для захисту від цього я роблю:

strncpy( dest, src, LEN );
dest[LEN - 1] = '\0';

man strncpy дає:

strncpy()Функція аналогічна, за винятком того, що не більше ніж nбайти srcкопіюються. Таким чином, якщо серед перших nбайтів немає нульового байта src, результат не закінчується нулем.

Без нульового припинення чогось, здавалося б, невинного типу:

   printf( "FOO: %s\n", dest );

... може зірватися.

Чи є кращі, безпечніші альтернативи strncpy()?

strncpy()не призначений для використання як безпечніший strcpy(), він повинен використовуватися для вставки одного рядка в середину іншого.

Всі ті "безпечні" функції обробки рядків, такі як snprintf()і vsnprintf()є виправленнями, які були додані в пізніших стандартах для пом'якшення використання переповнення буфера тощо.

Вікіпедія згадує strncat()як альтернативу написанню власного сейфу strncpy():

*dst = '\0';
strncat(dst, src, LEN);

РЕДАГУВАТИ

Я пропустив, що strncat()перевищує символи LEN при нульовому закінченні рядка, якщо він довший або дорівнює символу LEN.

У будь-якому випадку, сенс використання strncat()замість будь-якого доморощеного рішення, такого як memcpy(..., strlen(...))/ незалежно від того, що реалізація strncat()може бути цільовою / платформою, оптимізованою в бібліотеці.

Звичайно, вам потрібно перевірити, чи dst містить принаймні nullchar, тому правильне використання strncat()буде приблизно таким:

if (LEN) {
    *dst = '\0'; strncat(dst, src, LEN-1);
}

Я також визнаю, що strncpy()це не дуже корисно для копіювання підрядка в інший рядок, якщо src коротший за n char, рядок призначення буде усічений.

Спочатку файлова система UNIX 7-го видання (див. DIR (5)) мала записи каталогів, що обмежували імена файлів 14 байтами; кожен запис у каталозі складався з 2 байтів для номера inode плюс 14 байт для імені, заповненого нулем до 14 символів, але не обов'язково закінчуваного нулем. Я вважаю, що він strncpy()був розроблений для роботи з цими структурами каталогів - або, принаймні, він ідеально підходить для цієї структури.

Розглянемо:

• Ім'я файлу з 14 символів не припиняється з нулем.
• Якщо ім'я було коротше 14 байт, воно було заповнене нулем до повної довжини (14 байт).

Це саме те, чого можна було б досягти, якщо:

strncpy(inode->d_name, filename, 14);

Отже, strncpy()ідеально підійшов до своєї початкової нішевої програми. Йшлося лише випадково про запобігання переповненню рядків із нульовим закінченням.

(Зверніть увагу, що нульове заповнення до довжини 14 не є серйозними накладними витратами - якщо довжина буфера становить 4 КБ, і все, що вам потрібно, це безпечно скопіювати в нього 20 символів, то зайві 4075 нулів є серйозним надлишком, і їх легко можна призведе до квадратичної поведінки, якщо ви неодноразово додаєте матеріал у довгий буфер.)

Уже існують реалізації з відкритим кодом, такі як strlcpy які виконують безпечне копіювання.

http://en.wikipedia.org/wiki/Strlcpy

У посиланнях є посилання на джерела.

Strncpy безпечніший від атак переповнення стека користувачем вашої програми, він не захищає вас від помилок, які робить програміст, таких як друк рядка, що не закінчується нулем, як ви описали.

Ви можете уникнути збою описаної проблеми, обмеживши кількість символів, надрукованих printf:

char my_string[10];
//other code here
printf("%.9s",my_string); //limit the number of chars to be printed to 9

Деякі нові альтернативи вказані в ISO / IEC TR 24731 (перевірте https://buildsecurityin.us-cert.gov/daisy/bsi/articles/knowledge/coding/317-BSI.html ). Більшість із цих функцій приймають додатковий параметр, який визначає максимальну довжину цільової змінної, гарантує, що всі рядки мають нульове закінчення та мають імена, які закінчуються на _s(для "безпечного"?), Щоб відрізняти їх від попередніх "небезпечних" версій . ¹

На жаль, вони все ще отримують підтримку і можуть бути недоступними з вашим набором інструментів. Пізніші версії Visual Studio видаватимуть попередження, якщо ви використовуєте старі небезпечні функції.

Якщо ваші інструменти не підтримують нові функції, створити власні обгортки для старих функцій має бути досить просто. Ось приклад:

errCode_t strncpy_safe(char *sDst, size_t lenDst,
                       const char *sSrc, size_t count)
{
    // No NULLs allowed.
    if (sDst == NULL  ||  sSrc == NULL)
        return ERR_INVALID_ARGUMENT;

   // Validate buffer space.
   if (count >= lenDst)
        return ERR_BUFFER_OVERFLOW;

   // Copy and always null-terminate
   memcpy(sDst, sSrc, count);
   *(sDst + count) = '\0';

   return OK;
}

Ви можете змінити функцію відповідно до своїх потреб, наприклад, завжди копіювати якомога більшу кількість рядків без переповнення. Насправді реалізація VC ++ може це зробити, якщо ви передасте _TRUNCATEяк count.

Використання strlcpy(), зазначене тут:http://www.courtesan.com/todd/papers/strlcpy.html

Якщо у вашому libc немає реалізації, спробуйте це:

size_t strlcpy(char* dst, const char* src, size_t bufsize)
{
  size_t srclen =strlen(src);
  size_t result =srclen; /* Result is always the length of the src string */
  if(bufsize>0)
  {
    if(srclen>=bufsize)
       srclen=bufsize-1;
    if(srclen>0)
       memcpy(dst,src,srclen);
    dst[srclen]='\0';
  }
  return result;
}

(Написано мною у 2004 р. - присвячено загальнодоступному надбанню.)

strncpy працює безпосередньо з доступними рядковими буферами. Якщо ви працюєте безпосередньо зі своєю пам’яттю, то зараз ПОВИННІ розміри буферів, і ви можете встановити '\ 0' вручну.

Я вважаю, що кращої альтернативи в простому C немає, але насправді це не так вже й погано, якщо ви будете настільки обережні, як повинні бути, граючи з необробленою пам'яттю.

Замість strncpy(), ви могли б використовувати

snprintf(buffer, BUFFER_SIZE, "%s", src);

Ось однорядковий рядок, який копіює більшість size-1ненульових символів з srcдо destта додає нульовий термінатор:

static inline void cpystr(char *dest, const char *src, size_t size)
{ if(size) while((*dest++ = --size ? *src++ : 0)); }

Я завжди вважав за краще:

 memset(dest, 0, LEN);
 strncpy(dest, src, LEN - 1);

щоб виправити це згодом, але це насправді лише питання переваг.

Ці функції розвивалися більше, ніж були розроблені, тому насправді немає "чому". Потрібно просто навчитися "як". На жаль, принаймні сторінки з інструкціями для Linux позбавлені загальноприйнятих прикладів використання цих функцій, і я помітив багато зловживань у коді, який я переглядав. Я зробив кілька приміток тут: http://www.pixelbeat.org/programming/gcc/string_buffers.html

Не покладаючись на новіші розширення, я зробив щось подібне раніше:

/* copy N "visible" chars, adding a null in the position just beyond them */
#define MSTRNCPY( dst, src, len) ( strncpy( (dst), (src), (len)), (dst)[ (len) ] = '\0')

а можливо навіть:

/* pull up to size - 1 "visible" characters into a fixed size buffer of known size */
#define MFBCPY( dst, src) MSTRNCPY( (dst), (src), sizeof( dst) - 1)

Чому макроси замість новіших "вбудованих" (?) Функцій? Оскільки раніше існувало досить багато різних Unices, а також інших середовищ, не пов’язаних з unix (не Windows), які мені доводилося переносити назад, коли я щодня робив C.