[Перевод] main(){printf(&unix["\021%six\012\0"], (unix)[«have»]+«fun»-0x60);}28.10.2016 13:19

Развлекаемся, «распутывая» код на языке Си

Вызов: Прежде чем лезть под кат, скомпилируйте в голове заголовок статьи, что он дает на выходе?
image

Когда я в очередной раз просматривал книгу «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, которая разрабатывает Электронный сервис передач заключенным и реализовала вирусную рассылку информации.]
image

В «Expert C programming» об этом говорится следующее:
Избегайте любого использования препроцессора Си, которое изменяет базовый язык.
86646838fcd341eaa3817ae5d62a43b7.jpg

Одним из первых победителей в 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[]? Я уже видел подобное раньше, и это один из моих любимых фактов о языке Си.
image

Си берет начало в языке 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. В шестнадцатеричном представлении она выглядит как 0×61, вычитаем 0×60. Тогда останется 1+"fun".

Так же, как раньше, "fun" расшифровывается какchar *. Добавление 1 дает нам строку, начинающуюся со второго символа, то есть un. Тогда все превращается в это: 

main() {
  printf("%six\n", "un");
}

Вот и читабельный код.

Мне нравится, когда в запутанности кода большую роль играет семантика, то есть, когда, например, используют определенное слово unix, чтобы сбить вас с толку и заставить подумать, что оно переопределено и каким-то образом выводит свое имя. Символ \021 похож на инвертированный \012 и может заставить вас считать, что он необходим, хотя, по факту, не используется. Тут так же есть форматирующая строка %six, содержащая слово «six», видимо, чтобы вы приняли %s не за форматирование, а за что-нибудь другое.

Комментарии (1)

  • 28 октября 2016 в 13:04

    0

    ↑

    ↓

    В данный момент как раз изучаю сей труд :) Очень хорошая книжка.

© Habrahabr.ru