Почему printf с одним аргументом (без спецификаторов преобразования) устарел?

В книге, которую я читаю, написано, что printfиспользование одного аргумента (без спецификаторов преобразования) не рекомендуется. Рекомендуется заменить

printf("Hello World!");

с участием

puts("Hello World!");

или

printf("%s", "Hello World!");

Может кто подскажет, почему printf("Hello World!");не так? В книге написано, что в нем есть уязвимости. Что это за уязвимости?

printf("Hello World!"); IMHO не уязвим, но учтите это:

const char *str;
...
printf(str);

Если strпроизойдет указание на строку, содержащую %sспецификаторы формата, ваша программа будет демонстрировать неопределенное поведение (в основном сбой), тогда puts(str)как строка будет отображаться как есть.

Пример:

printf("%s");   //undefined behaviour (mostly crash)
puts("%s");     // displays "%s\n"

printf("Hello world");

в порядке и не имеет уязвимости в системе безопасности.

Проблема заключается в следующем:

printf(p);

где p- указатель на ввод, которым управляет пользователь. Он подвержен атакам на строки форматирования : пользователь может вставлять спецификации преобразования, чтобы получить контроль над программой, например, %xдля дампа памяти или %nперезаписи памяти.

Обратите внимание, что puts("Hello world")поведение не эквивалентно, printf("Hello world")но printf("Hello world\n"). Компиляторы обычно достаточно умны, чтобы оптимизировать последний вызов, чтобы заменить его puts.

В дополнение к другим ответам, printf("Hello world! I am 50% happy today")это простая ошибка, потенциально вызывающая всевозможные неприятные проблемы с памятью (это UB!).

Просто проще, проще и надежнее «требовать» от программистов, чтобы они были абсолютно ясны, когда им нужна дословная строка и ничего больше .

И это то, что printf("%s", "Hello world! I am 50% happy today")вас заводит. Это полностью надежно.

(Стив, конечно printf("He has %d cherries\n", ncherries), совершенно не то же самое; в данном случае программист не придерживается мышления «дословная строка»; она придерживается мышления «строка формата».)

Я просто добавлю здесь немного информации об уязвимости .

Он считается уязвимым из-за уязвимости формата строки printf. В вашем примере, где строка жестко запрограммирована, она безвредна (даже если такие жесткие строки никогда не рекомендуется полностью). Но указывать типы параметров - хорошая привычка. Вот пример:

Если кто-то помещает символ строки формата в ваш printf вместо обычной строки (скажем, если вы хотите распечатать программу stdin), printf возьмет все, что сможет, в стек.

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

Пример (C):

int main(int argc, char *argv[])
{
    printf(argv[argc - 1]); // takes the first argument if it exists
}

если я поставлю как вход этой программы "%08x %08x %08x %08x %08x\n"

printf ("%08x %08x %08x %08x %08x\n"); 

Это дает указание функции printf извлечь пять параметров из стека и отобразить их в виде 8-значных шестнадцатеричных чисел с дополнениями. Таким образом, возможный результат может выглядеть так:

40012980 080628c4 bffff7a4 00000005 08059c04

Смотрите это для более полного объяснения и других примеров.

Вызов printfс использованием буквальных строк формата безопасен и эффективен, и существуют инструменты, которые автоматически предупреждают вас, если ваш вызов printfс использованием строк формата, предоставленных пользователем, небезопасен.

Самые серьезные атаки на printfиспользование %nспецификатора формата. В отличие от всех других спецификаторов формата, например %d, %nфактически записывает значение в адрес памяти, указанный в одном из аргументов формата. Это означает, что злоумышленник может перезаписать память и таким образом потенциально получить контроль над вашей программой. Википедия предоставляет более подробную информацию.

Если вы вызываете printfс буквальной строкой формата, злоумышленник не сможет проникнуть %nв вашу строку формата, и, таким образом, вы в безопасности. Фактически, gcc изменит ваш вызов printfна вызов puts, поэтому практически нет никакой разницы (проверьте это, запустив gcc -O3 -S).

Если вы вызываете printfс помощью предоставленной пользователем строки формата, злоумышленник потенциально может проникнуть %nв вашу строку формата и получить контроль над вашей программой. Ваш компилятор обычно предупреждает вас, что это небезопасно, см -Wformat-security. Существуют также более продвинутые инструменты, которые гарантируют, что вызов printfбезопасен даже с предоставленными пользователем строками формата, и они могут даже проверить, что вы передаете правильное количество и тип аргументов printf. Например, для Java есть Google's Error Prone и Checker Framework .

Это ошибочный совет. Да, если у вас есть строка времени выполнения для печати,

printf(str);

довольно опасно, и вы всегда должны использовать

printf("%s", str);

вместо этого, потому что, как правило, никогда нельзя узнать, strможет ли он содержать %знак. Однако, если у вас есть постоянная строка времени компиляции , нет ничего плохого в

printf("Hello, world!\n");

(Среди прочего, это самая классическая программа на языке C, буквально из книги по программированию на языке C в Genesis. Так что любой, кто не одобряет такое использование, является довольно еретическим, и я, например, был бы несколько оскорблен!)

Довольно неприятный аспект printfзаключается в том, что даже на платформах, где случайное чтение из памяти может причинить только ограниченный (и приемлемый) вред, один из символов форматирования %nприводит к интерпретации следующего аргумента как указатель на записываемое целое число и вызывает количество выведенных символов, которые будут сохранены в идентифицированной им переменной. Я сам никогда не использовал эту функцию, и иногда я использую облегченные методы в стиле printf, которые я написал, чтобы включать только те функции, которые я действительно использую (и не включать их или что-то подобное), но подавать стандартные строки функций printf, полученные из ненадежных источников может выявить уязвимости безопасности, помимо возможности чтения произвольного хранилища.

Поскольку никто не упомянул, я бы добавил примечание об их производительности.

При нормальных обстоятельствах, предполагая, что никакие оптимизации компилятора не используются (т.е. printf()фактически вызывает, printf()а не нет fputs()), я ожидал printf()бы работать менее эффективно, особенно для длинных строк. Это связано с тем, printf()что необходимо проанализировать строку, чтобы проверить, есть ли какие-либо спецификаторы преобразования.

Чтобы подтвердить это, я провел несколько тестов. Тестирование проводится на Ubuntu 14.04 с gcc 4.8.4. Моя машина использует процессор Intel i5. Тестируемая программа выглядит следующим образом:

#include <stdio.h>
int main() {
    int count = 10000000;
    while(count--) {
        // either
        printf("qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM");
        // or
        fputs("qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM", stdout);
    }
    fflush(stdout);
    return 0;
}

Оба скомпилированы с использованием gcc -Wall -O0. Время измеряется с помощью time ./a.out > /dev/null. Ниже приведен результат типичного запуска (я запускал их пять раз, все результаты в пределах 0,002 секунды).

Для printf()варианта:

real    0m0.416s
user    0m0.384s
sys     0m0.033s

Для fputs()варианта:

real    0m0.297s
user    0m0.265s
sys     0m0.032s

Этот эффект усиливается, если у вас очень длинная струна.

#include <stdio.h>
#define STR "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM"
#define STR2 STR STR
#define STR4 STR2 STR2
#define STR8 STR4 STR4
#define STR16 STR8 STR8
#define STR32 STR16 STR16
#define STR64 STR32 STR32
#define STR128 STR64 STR64
#define STR256 STR128 STR128
#define STR512 STR256 STR256
#define STR1024 STR512 STR512
int main() {
    int count = 10000000;
    while(count--) {
        // either
        printf(STR1024);
        // or
        fputs(STR1024, stdout);
    }
    fflush(stdout);
    return 0;
}

Для printf()варианта (пробежал три раза, реальные плюс / минус 1,5 с):

real    0m39.259s
user    0m34.445s
sys     0m4.839s

Для fputs()варианта (запускался трижды, реальные плюс / минус 0,2 с):

real    0m12.726s
user    0m8.152s
sys     0m4.581s

Примечание: после проверки сборки, созданной gcc, я понял, что gcc оптимизирует fputs()вызов для fwrite()вызова даже с -O0. ( printf()Вызов остается неизменным.) Я не уверен, аннулирует ли это мой тест, поскольку компилятор вычисляет длину строки для fwrite()во время компиляции.

printf("Hello World\n")

автоматически компилируется в эквивалент

puts("Hello World")

вы можете проверить это с помощью дизассемблирования исполняемого файла:

push rbp
mov rbp,rsp
mov edi,str.Helloworld!
call dword imp.puts
mov eax,0x0
pop rbp
ret

с помощью

char *variable;
... 
printf(variable)

приведет к проблемам с безопасностью, никогда не используйте printf таким образом!

так что ваша книга на самом деле правильная, использование printf с одной переменной устарело, но вы все равно можете использовать printf ("моя строка \ n"), потому что она автоматически станет put

Для gcc можно включить определенные предупреждения для проверки printf()и scanf().

В документации gcc указано:

-Wformatвходит в -Wall. Для большего контроля над некоторыми аспектами формата проверка, параметров -Wformat-y2k, -Wno-format-extra-args, -Wno-format-zero-length, -Wformat-nonliteral, -Wformat-security, и -Wformat=2доступны, но не включены в -Wall.

-Wformat, Который включен в -Wallопции не позволяет несколько специальных предупреждений , которые помогают найти эти случаи:

• -Wformat-nonliteral выдаст предупреждение, если вы не передадите строковое буквенное обозначение в качестве спецификатора формата.
• -Wformat-securityпредупредит, если вы передадите строку, которая может содержать опасную конструкцию. Это подмножество -Wformat-nonliteral.

Я должен признать, что включение -Wformat-securityвыявило несколько ошибок, которые у нас были в нашей кодовой базе (модуль регистрации, модуль обработки ошибок, модуль вывода xml, у всех были некоторые функции, которые могли бы делать неопределенные вещи, если бы они были вызваны с символами% в их параметре. Для информации, нашей кодовой базе сейчас около 20 лет, и даже если бы мы знали об этих проблемах, мы были чрезвычайно удивлены, когда включили эти предупреждения, сколько из этих ошибок все еще было в кодовой базе).

Помимо других хорошо объясненных ответов с затронутыми побочными проблемами, я хотел бы дать точный и краткий ответ на заданный вопрос.

Почему printfиспользование одного аргумента (без спецификаторов преобразования) устарело?

printfВызов функции с одним аргументом в целом не устарела и не имеет также не уязвимостей при правильном использовании , как вы всегда должны кодировать.

C Пользователи всего мира, от новичка до статусного эксперта, используют printfэтот способ для вывода простой текстовой фразы на консоль.

Более того, Кто-то должен различать, является ли этот единственный аргумент строковым литералом или указателем на строку, которая действительна, но обычно не используется. Для последнего, конечно, могут возникать неудобные выходные данные или любое неопределенное поведение , когда указатель не установлен должным образом, чтобы указывать на допустимую строку, но эти вещи также могут происходить, если спецификаторы формата не соответствуют соответствующим аргументам, давая несколько аргументов.

Конечно, также неправильно и неправильно, чтобы строка, предоставленная в качестве одного-единственного аргумента, имела какие-либо спецификаторы формата или преобразования, поскольку преобразование не произойдет.

Тем не менее, предоставление простого строкового литерала, такого "Hello World!"как единственный аргумент, без каких-либо спецификаторов формата внутри этой строки, как вы указали в вопросе:

printf("Hello World!");

не является устаревшим и не является " плохой практикой ", и не имеет никаких уязвимостей.

Фактически, многие программисты на C начинают и начинают изучать и использовать C или даже языки программирования в целом с этой программы HelloWorld и этого printfоператора как первых в своем роде.

Их бы не было, если бы они были устаревшими.

В книге, которую я читаю, написано, что printfиспользование одного аргумента (без спецификаторов преобразования) не рекомендуется.

Что ж, тогда я сосредоточился бы на книге или на самом авторе. Если автор действительно делает такие, на мой взгляд, неправильные утверждения и даже преподает это, не объясняя явно, почему он / она это делает (если эти утверждения действительно буквально эквивалентны приведенным в этой книге), я бы счел это плохой книгой. Хорошая книга, в отличие от этого, должна объяснить , почему , чтобы избежать определенного рода программирования методов или функций.

Согласно тому, что я сказал выше, использование printfтолько с одним аргументом (строковым литералом) и без каких-либо спецификаторов формата ни в коем случае не считается устаревшим и не считается «плохой практикой» .

Вы должны спросить автора, что он имел в виду, или, что еще лучше, попросите его уточнить или исправить соответствующий раздел для следующего издания или отпечатков в целом.