C C · 25 вопросов · ~70 мин · ⏱ Таймер 10:00 · Средний ·

Безопасная обработка строк

Тест рассматривает строку как буфер с точным контрактом: вместимость, завершающий ноль, форматные типы, копирование, числовой разбор и согласованность интерфейсов с явной длиной. Задания построены вокруг реальных причин переполнений и уязвимостей форматной строки.

Отвечено: 0 из 25

⏱ --:--

💡 Инструкция: Выберите один ответ из пяти. На 25 вопросов отведено 70 минут. Код читайте построчно: часть заданий проверяет вывод, часть — поиск дефекта, переносимость и безопасное исправление. После завершения откроются объяснения и профиль по 5 темам.

Вопрос 1 из 25

Сколько байтов нужно выделить для копии корректной C-строки `s`?

size_t n=strlen(s); if(n==SIZE_MAX) fail(); char *p=malloc(n+1);

`strlen(s) - 1` Ровно `strlen(s)` Вдвое больше `strlen(s)` Всегда `sizeof(s)` `strlen(s) + 1` после проверки сложения

Вопрос 2 из 25

Сколько байтов нужно зарезервировать в буфере для строки длиной `n` символов?

Ровно `n`: строка и так хранит символы, терминатор учтён внутри `strlen` Зависит от кодировки: для однобайтовых строк достаточно `n`, для многобайтовых нужен множитель `n * 2`: двойной запас на случай расширения строки `n - 1`: `strlen` включает нулевой байт в подсчёт `n + 1`: один дополнительный байт для завершающего нулевого символа

Вопрос 3 из 25

Как вычислить размер буфера для `prefix + name + suffix + NUL`?

Сначала привести каждую длину к `int` Скопировать части и после этого измерить получившуюся строку Сложить длины без проверок и передать результат в `malloc` Не учитывать суффикс: его добавит `strcat` Проверять каждое сложение относительно `SIZE_MAX`, затем выделить итоговый размер

Вопрос 4 из 25

Что означает вызов `snprintf` с размером буфера, равным нулю?

int r=snprintf(NULL,0,"%s:%d",name,id);

Такой режим определён только для POSIX; ISO C требует ненулевой буфер, даже если запись не выполняется Ничего не пишет; при `n == 0` назначение может быть `NULL` Функция проверяет указатель назначения до размера, поэтому даже при `n == 0` требуется адрес доступного массива Возвращаемое значение равно числу фактически записанных байтов, поэтому при нулевом размере оно равно нулю Библиотека создаёт внутреннюю строку, а возвращаемое значение равно числу байтов в этом временном буфере

Вопрос 5 из 25

Почему текущую длину строки и вместимость буфера нужно хранить раздельно?

Вместимость — это длина до первого NUL, а текущая длина — размер выделенного блока Вместимость хранит адрес конца буфера, поэтому её нельзя сравнивать с числовой длиной Длину следует хранить в знаковом типе, а вместимость — в беззнаковом; этим различие исчерпывается Разделение нужно лишь для оформления: обе величины при корректной строке всегда равны Длина описывает инициализированные данные, а вместимость задаёт границу записи

Вопрос 6 из 25

Почему вызов `printf(user_input)` уязвим?

printf(user_input);

Пользовательская строка управляет спецификаторами формата, чтением отсутствующих аргументов и `%n` Компилятор экранирует проценты в значениях, полученных во время выполнения Формат должен быть строковым литералом, поэтому переменная не компилируется Проблема вызвана буферизацией `stdout`, а не интерпретацией формата Уязвимость возникает при нулевой длине входа, когда формат не содержит символов

Вопрос 7 из 25

Какой спецификатор `printf` соответствует типу `size_t`?

printf("%zu\n",n);

`%d` `%zu` `%ld` на любой платформе `%p` `%u` на любой платформе

Вопрос 8 из 25

Как определить, что `snprintf` обрезала результат?

int r=snprintf(buf,cap,"%s",s);

Обрезание определяется равенством `r == cap`, а большие значения означают другую ошибку Отрицательный `r` означает ошибку кодирования, а неотрицательный `r >= cap` — недостаточную вместимость Для вывода достаточно проверить `errno`, возвращаемое значение не связано с вместимостью Функция либо записывает весь результат, либо возвращает отрицательное значение Нужно сравнить фактическую `strlen(buf)` с `cap` после вызова

Вопрос 9 из 25

Почему `%d` нельзя использовать для аргумента типа `long`?

long x=1; printf("%d\n",x);

Формат `%d` выводит адрес аргумента `printf` автоматически преобразует любой целый аргумент к `int` Тип `long` не является числовым Это лишь стилистическое предупреждение без влияния на поведение Тип аргумента обязан точно совпасть со спецификатором

Вопрос 10 из 25

Какие флаги компилятора особенно полезны для проверки форматных строк?

void log_user(const char *name) {
    printf(name); /* компилятор должен предупредить об опасной форматной строке */
}

`-Wformat=2 -Wformat-security` `-w`, отключающий предупреждения Только `-E` `-nostdlib` Только `-s`

Вопрос 11 из 25

Когда нужен `memmove` вместо `memcpy`?

memmove(buf+1,buf,n);

Только для буферов, полученных чтением из файла через `fread` Когда требуется более быстрый вариант `memcpy`, поскольку `memmove` не проверяет границы Когда копируется строка неизвестной длины, даже если области памяти гарантированно не пересекаются Только при нулевом количестве байтов, потому что `memcpy` требует положительную длину Когда источник и назначение могут перекрываться, а направление безопасного копирования заранее неизвестно

Вопрос 12 из 25

Почему `strncpy` может оставить результат без завершающего нуля?

strncpy(dst,src,cap);

Если исходная строка длиннее буфера, `strncpy` уменьшает `n` на единицу только при включённых предупреждениях При длине не меньше `n` копирует `n` байтов без NUL Нулевой байт гарантируется после успешного вызова, но может быть удалён последующим вызовом `strlen` При ненулевом `n` функция всегда резервирует последний байт под ``, а проблема возникает только при `n == 0` Завершающий ноль теряется лишь тогда, когда исходная строка и буфер назначения перекрываются

Вопрос 13 из 25

Какой контракт ограниченного копирования наиболее прозрачен?

Считать любой недостаточный буфер успешным вызовом Копировать `cap + 1` байтов для надёжности Вернуть нужную длину или статус и гарантировать NUL при `cap > 0` Не возвращать результат и полагаться на глобальную переменную Всегда молча обрезать данные и ничего не сообщать

Вопрос 14 из 25

Почему `memcpy(dst, src, strlen(src))` не создаёт корректную копию строки?

size_t n=strlen(src); memcpy(dst,src,n);

Буфер `dst` автоматически заполняется нулями `strlen` уже включает завершающий ноль `memcpy` сама добавляет завершающий ноль В копирование не входит завершающий нулевой байт Ошибка возникает только для пустой строки

Вопрос 15 из 25

Можно ли копировать структуру с помощью `memcpy`?

Да, указатели внутри структуры превращаются в независимые глубокие копии Да, но стандарт гарантирует копирование только первого объявленного поля Да, и полученный набор байтов можно использовать как переносимый файловый формат Нет, побайтовое копирование определено лишь для массивов символьного типа Да, между совместимыми объектами; поля-указатели при этом копируются как значения адресов

Вопрос 16 из 25

Почему `atoi` плохо подходит для разбора недоверенного числа?

int value = atoi(s);

Она работает слишком быстро для проверки ввода Она возвращает указатель вместо числа Любой её вызов имеет неопределённое поведение Не различает ошибку и ноль и не сообщает переполнение Она поддерживает только шестнадцатеричную запись

Вопрос 17 из 25

Как отклонить лишние символы после числа, разобранного `strtol`?

char *end;
long value = strtol(s, &end, 10);
/* Выберите проверку, которая требует разбора всего поля. */

Использовать `atoi`, поскольку он отвергает строку, если после числа остаются символы Проверить только `end == s`; любой непустой числовой префикс делает всё поле допустимым Достаточно проверить `errno`: ненулевое значение означает наличие хвоста после числа Проверить `end != s` и `*end == '\0'` Сравнить `strlen(s)` с числом разобранных цифр, не используя конечный указатель

Вопрос 18 из 25

Чем опасен встроенный NUL в данных с явной длиной, если затем их передать строковому интерфейсу?

Расхождение возможно для UTF-16, но не для байтовых строк C Строковый интерфейс отображает нулевой байт как пробел и продолжает чтение Проверяющий слой может принять все байты, а строковый потребитель увидит лишь префикс до NUL Все интерфейсы с явной длиной и строковые функции интерпретируют встроенный NUL одинаково Нулевой байт сообщает распределителю, что буфер нужно расширить

Вопрос 19 из 25

Когда нужно проверять максимально допустимую длину входа?

if(input_len>MAX_NAME) return TOO_LONG;

После вычисления размера, выделения памяти и копирования: тогда известна фактическая стоимость входа После освобождения временного буфера, чтобы лимит не влиял на рабочий путь Перед выводом пользователю; внутренние этапы могут принимать произвольную длину Только для строк, которые затем передаются в функции семейства `printf` До арифметики размеров, выделения памяти и передачи дальше

Вопрос 20 из 25

Гарантирует ли нулевой терминатор корректность UTF-8?

`strlen` одновременно вычисляет длину и проверяет правила кодировки Да для строк, содержащих ASCII, а остальные байты библиотека исправляет при чтении Терминатор заменяет незавершённую многобайтовую последовательность корректным символом Да: завершение NUL подтверждает структуру всех многобайтовых символов Нет: наличие терминатора ничего не говорит о допустимости последовательностей UTF-8

Вопрос 21 из 25

Какой санитайзер компилятора лучше всего обнаружит переполнение стекового буфера на выполненном пути?

void copy_name(const char *src) {
    char buf[16];
    strcpy(buf, src);
    use(buf);
}

UndefinedBehaviorSanitizer, ориентированный на отдельные виды неопределённого поведения LeakSanitizer, ищущий неосвобождённые выделения к завершению процесса AddressSanitizer, инструментирующий стек, кучу и глобальные области памяти ThreadSanitizer, отслеживающий конфликтующие обращения потоков MemorySanitizer, предназначенный прежде всего для чтения неинициализированных данных

Вопрос 22 из 25

Зачем добавлять встроенный NUL в набор входов для фаззинга парсера?

Чтобы найти расхождение явной длины и строковых функций Только для измерения производительности Чтобы проверить цвет диагностических сообщений Такой байт невозможен во входных данных Чтобы принудительно установить признак конца файла

Вопрос 23 из 25

Что даёт `_FORTIFY_SOURCE` на поддерживаемой платформе?

Шифрование буферов перед копированием, если компилятор знает их размер Полное доказательство отсутствия переполнений для всех вызовов функций стандартной библиотеки Гарантию отсутствия дополнительных проверок и накладных расходов в сгенерированном коде Дополнительные проверки библиотеки при известных размерах объектов Замена `malloc` распределителем, который автоматически увеличивает слишком маленькие объекты

Вопрос 24 из 25

Как безопасно записать в журнал недоверенный буфер без нулевого терминатора?

fwrite(buf,1,n,stderr);

Передать буфер в `%s`, предварительно ограничив ширину поля значением `n` Преобразовать адрес буфера к `FILE *` и вызвать `fputs` Записать NUL в `buf[n]`, полагая, что после входного диапазона всегда есть свободный байт Вызвать `strlen(buf)` и использовать найденное значение как безопасную длину Печатать с явной длиной, экранированием и пределом объёма

Вопрос 25 из 25

Какой регрессионный тест нужен после исправления переполнения буфера?

Удалить вход после исправления, чтобы регрессионный набор не зависел от старого дефекта Минимальный вход, соседние границы и запуск под санитайзером Оставить только пустую строку, поскольку она покрывает минимальный возможный размер Сохранить только исходный аварийный вход: соседние размеры уже не относятся к исправленной ошибке Проверить выпускную сборку без предупреждений и санитайзеров: она ближе к работе пользователя

Ответьте на все 25 вопросов, чтобы получить результат

🔗 Встроить тест на свой сайт (iframe) ▼

Скопируйте код и вставьте в любое место на вашем сайте:

Также доступна прямая ссылка на embed-страницу