Развлекаемся, «распутывая» код на языке Си
Вызов: Прежде чем лезть под кат, скомпилируйте в голове заголовок статьи, что он дает на выходе?
Когда я в очередной раз просматривал книгу «Expert C programming», я вдруг наткнулся на раздел «light relief» в международном конкурсе на самый запутанный код на Си (IOCCC). Это соревнование по написанию как можно более нечитабельного кода. То, что такие конкурсы устраиваются для Си, наверное, говорит что-что об этом языке. Мне хотелось увидеть работы участников этого соревнования. Не найдя никакой информации в интернете, я решил поискать их самостоятельно.
IOCCC был придуман Стивеном Борном, когда он решил использовать препроцессор Си и написать Unix shell как бы на языке Си, но больше похожем на язык Algol-68, с его явными окончаниями операторов, например:
if
...
fi Он добился этого, сделав:
#define IF if(
#define THEN ){
#define ELSE } else {
#define FI ;}
Что позволило ему писать так:
IF *s2++ == 0
THEN return(0);
FI
Мы в компании EDISON также много «развлекаемся» на C, создавая ПО для клиентов.
Но при этом соблюдается железное правило: любое подобное «развлечение» должно проходить по правилам каскадного цикла разработки или гибкой методологии Agile.
В «Expert C programming» об этом говорится следующее:
Избегайте любого использования препроцессора Си, которое изменяет базовый язык.
Одним из первых победителей в 1987 году был Дэвид Корн, создатель Korn shell’а (что не так с этими shell-райтерами?), который написал всего одну строчку:
main(){printf(&unix["\021%six\012\0"], (unix)["have"]+"fun"-0x60);}
Вот и все. Попробуйте скомпилировать это. Что будет выведено?
Этот код не запустится на Майкрософте (подсказка!), но вот ссылка на онлайн компилятор, который справится с этой задачей. Там добавлено несколько строк, чтобы оно заработало, но в остальном — все то же самое.
Код всего лишь выводит:
unix
Но почему? В коде есть что-то, что выглядит как массив с названием
unix, но он не был декларирован. Тогда unix — это ключевое слово? Оно каким-то образом выводит имя переменной?Я вслепую попытался проверить это, добавив:
printf(unix);
И он вывел мне ошибку, сказав, что
printf принимает char *, а не int.Когда я вывел эту переменную как
int, стало понятно, что ее значение равно 1. Это натолкнуло меня на мысль, что она была переопределена, как если бы код был скомпилирован в Unix-системе. Поискав на gcc source code, я нашел, что это run-time target specification. Это объясняет, почему код не запустится на Windows.unix — это просто 1. Переписав, получим:main(){printf(&1["\021%six\012\0"], (1)["have"]+"fun"-0x60);}
Итак,
unix не было названием переменной. Но тогда как же работает 1[]? Я уже видел подобное раньше, и это один из моих любимых фактов о языке Си.
Си берет начало в языке BCPL. Его создатель — доктор Мартин Ричардс, писал:
Оператор косвенного обращения! принимает указатель в качестве аргумента и возвращает содержание ячейки, на которую тот указывает. Если v — указатель, то !(v+i) будет обращаться к ячейке с адресом v+i. Бинарная версия оператора! определена так, что v!i = !(v+i). v!i ведет себя как индексированное представление, где v — одномерный массив, а i — индекс типа integer. Заметьте, что в языке BCPL v5= !(v+5) =! (5+v) = 5!v. То же происходит и в языке Си: v[5] = 5[v].
Другими словами, индексы просто складываются с указателями, а так как сложение коммутативно, то коммутативен и оператор индексирования. Попробуем изменить и это тоже:
int x[] = {1, 2, 3};
printf("%d\n%d\n", x[1], 1[x]);
Тогда что есть
1["\021%six\012\0"]? Написав в привычном виде, увидим доступ к элементам массива через оператор индексирования:"\021%six\012\0"[1]. Все равно нетипично, но уже понятно, что этоarray[index], хотя, как правило, строковые литералы так не используют. Но это работает, поэтому попробуем следующее: printf("%c\n", "hello, world"[1]);
Давайте перепишем только первый массив, пока разбираемся с этим.
main() {
char str[] = "\021%six\012\0";
printf(&str[1], (1)["have"]+"fun"-0x60);
}
Все еще работает так же. Посмотрев на
str, я задумался о \0, который является null character’ом (или NUL character’ом?). Я думал, что строковые литералы в Си по умолчанию имеют null character. Поглядим, что получится, если мы удалим его: printf("%s", "\021%six\012");
Выводит:
%six
Я использую форматирование строк
"%s", потому что строка, которую я пытаюсь вывести, содержит форматирующий символ %. (Небольшая подсказка: не выводите такие строки как printf(myStr), когда они имеют форматирующие символы. Вывод через %s показан выше.) Кажется, оно по-прежнему работает без
\0. Может, в каком-нибудь пре-ANSI Си нужно было самому добавлять null character'ы в строковые литералы? Думаю, нет, так как другие строки в программе их не имеют. Или так просто выглядит более запутанно? Ладно, оставим пока этот \0.Раз уж остановились на этой строке, давайте посмотрим на ее остальную часть.
\xxx — представление каждого символа в восьмеричной системе счисления, \021 — некий управляющий символ, а \012 — символ перевода строки или \n, как мы его привыкли видеть, в конце выводимых строк.Зная, что
\021 — это всего один символ, поймем, что str[1] есть %. Тогда &str[1] — строка, начинающаяся с %. Значит строкой на самом деле может быть просто %six\n, без управляющего символа, который не понятно зачем тут нужен.main() {
char str[] = "%six\n";
printf(str, (1)["have"]+"fun"-0x60);
}
Первая строка, передаваемая в
printf, это форматирующая строка, %s означает «помести следующую строку вместо этой». Так как эта строка заканчивается на ix, можно предположить, что следующая переданная в printf строка каким-то образом должна выглядеть как un. Запросто избавимся от массива character’ов, который мы использовали, чтобы передать форматирующую строку, и получим:main() {
printf("%six\n", (1)["have"]+"fun"-0x60);
}
В следующей строке имеем:
(1)["have"]+"fun"-0x60. Тут есть un, что содержится в слове fun, так что давайте разберем ее.Снова видим этот трюк с индексированием:
(1)["have"]. Круглые скобки вокруг 1 не нужны. Опять же, это требовалось в старом Си или сделано для большей нечитабельности? "have"[1] — это a. В шестнадцатеричном представлении она выглядит как 0x61, вычитаем 0x60. Тогда останется 1+"fun".Так же, как раньше,
"fun" расшифровывается как char *. Добавление 1 дает нам строку, начинающуюся со второго символа, то есть un. Тогда все превращается в это:main() {
printf("%six\n", "un");
}
Вот и читабельный код.
Мне нравится, когда в запутанности кода большую роль играет семантика, то есть, когда, например, используют определенное слово
unix, чтобы сбить вас с толку и заставить подумать, что оно переопределено и каким-то образом выводит свое имя. Символ \021 похож на инвертированный \012 и может заставить вас считать, что он необходим, хотя, по факту, не используется. Тут так же есть форматирующая строка %six, содержащая слово «six», видимо, чтобы вы приняли %s не за форматирование, а за что-нибудь другое.Перевод: Алена Карнаухова
