Для того, чтобы рассказать в чём смысл, надо для начала немного углубиться в то как работает этот компилятор.<\/p>\n
Компилятор, когда разбирает код, делит его на токены по пробелу, после каждый токен хешируется функцией atoi<\/tt> в двухбайтовое число и уже по нему определяется является ли встреченное ключевым словом языка, либо именем функции или переменной.<\/p>\n
В последнем случае, имя, преобразованное в число, будет в машинных кодах использовано как смещение, указывающее на ячейку со значением переменной или с указателем на тело функции.<\/p>\n
Отсюда следует, что последовательно называющиеся переменные — a<\/tt>, b<\/tt>, c<\/tt> и так далее, с будут в памяти располагаться последовательно со смещением в два байта, точностью до переполнения. При этом их даже не обязательно определять — переменная с любым именем существует с начальным нулевым значением.<\/p>\n
Идём дальше.<\/p>\n
В языке есть любопытная операция — &<\/tt>, позволяющая получить адрес переменной, который, напомню, равен одновременно хешу (atoi<\/tt>) к её имени. Для однобуквенных имён это позволяет по полученному адресу восстановить код символа — надо поделить полученное значение на два и добавить 48 — код символа 0<\/tt>.<\/p>\n
Таким образом, передав в функцию адреса & H<\/tt>, & e<\/tt>, & l<\/tt>, & l<\/tt>, & o<\/tt>, мы сможем восстановить из них символы и составить из них слово Hello<\/tt>. Если записать эти адреса в переменные, которые располагаются в памяти подряд, можно, читая память последовательно, выводить закодированную строку.<\/p>\n
Есть ли в языке способ прочитать что-то по адресу? Как ни странно, есть — токен *(int*)<\/tt> позволяющий это сделать.<\/p>\n
Теперь всё вышесказанное можно соединить в следующий довольно компактный код:<\/p>\n
void print_str()\r\n{\r\n print_str_pointer = & _0;\r\n while( *(int*) print_str_pointer ){\r\n print_ch = ( *(int*) print_str_pointer >> 1 ) + 48; print_char();\r\n print_str_pointer = print_str_pointer + 2;\r\n }\r\n}\r\n\r\nvoid main()\r\n{\r\n _0 = & H; _1 = & e; _2 = & l; _3 = & l; _4 = & o; _5 = 0;\r\n print_str(); \/\/ Hello\r\n}<\/code><\/pre>",
"date_published": "2023-06-24T21:49:21+05:00",
"date_modified": "2023-06-24T21:49:18+05:00",
"tags": [
"sectorc",
"программирование",
"си"
],
"author": {
"name": "Евгений Степанищев",
"url": "https:\/\/bolknote.ru\/",
"avatar": "https:\/\/bolknote.ru\/pictures\/userpic\/userpic@2x.jpg?1760600028"
},
"_date_published_rfc2822": "Sat, 24 Jun 2023 21:49:21 +0500",
"_rss_guid_is_permalink": "false",
"_rss_guid": "120944",
"_rss_enclosures": [],
"_e2_data": {
"is_favourite": false,
"links_required": null,
"og_images": []
}
},
{
"id": "120446",
"url": "https:\/\/bolknote.ru\/all\/return-v-sectorc\/",
"title": "return в SectorC",
"content_html": "Вчера перед сном пришло в голову, что один из недостатков языка SectorC<\/i>, — отсутствие конструкции return<\/tt>, можно отчасти компенсировать средствами самого языка. Достаточно написать функцию return()<\/tt>, которая будет делать две вещи — возвращать значение (об этом ниже) и прерывать выполнение функции из которой её вызвали.<\/p>\n
Я уже достаточно знаю об его внутренностях, чтобы понимать как это можно сделать.<\/p>\n
Второе реализовать совсем просто, тут мне помогает некогда богатый опыт программирования на Ассемблерах. SectorC<\/i> транслируется напрямую в машинный код, а значит адреса возвратов из функций хранятся на стеке. Так что надо всего лишь удалить верхний адрес возврата и мы вернёмся не в функцию, которая нас вызвала, а на уровень выше. Я делаю это командой pop ax<\/tt>.<\/p>\n
Теперь посмотрим на первую задачу.<\/p>\n
Как я уже писал<\/a> язык устроен так, что присваивание переменных друг другу происходит через регистр AX<\/tt>, таким образом, присваивая переменную самой себе, мы помещаем её в этот регистр. Этот факт используется в стандартной библиотеке языка, так что можно считать, что это стабильное поведение.<\/p>\nНапрашивается следующая реализация, — перед вызовом присваиваем возвращаемую переменную самой себе, в функции return()<\/tt> записываем содержимое AX<\/tt> в какую-нибудь переменную (я выбрал return<\/tt>) и возвращаемся.<\/p>\n
Моя реализация вместе с примером использования ниже:<\/p>\n
void return()\r\n{\r\n \/\/ mov [&return, ax]\r\n asm 163; asm 236; asm 229;\r\n \/\/ pop ax (clear stack from prev return address)\r\n asm 88;\r\n}\r\n\r\nvoid random()\r\n{\r\n \/\/ xor ax, ax int 0x1A xchg ax, dx\r\n asm 49; asm 192; asm 205; asm 26; asm 146;\r\n \/\/ xor dx, dx mov cx, 10\r\n asm 49; asm 210; asm 185; asm 10; asm 0;\r\n \/\/ div cx inc dx xchg ax, dx\r\n asm 247; asm 241; asm 66; asm 146;\r\n return();\r\n}\r\n\r\nvoid function()\r\n{\r\n i = 0; while( i < 20 ){\r\n random();\r\n if( i > return ){\r\n i = i; return();\r\n }\r\n i = i + 1;\r\n }\r\n\r\n i = 0; return();\r\n}\r\n\r\nvoid main()\r\n{\r\n function();\r\n print_num = return; print_u16();\r\n}<\/code><\/pre>Кстати, возникает любопытный сторонний эффект — так как через AX<\/tt> делается не только присваивание, а вообще все операции, то функция return()<\/tt> захватывает любое последнее вычисленное выражение, что тоже может быть удобно.<\/p>\n",
"date_published": "2023-06-17T08:37:44+05:00",
"date_modified": "2023-06-17T08:36:48+05:00",
"tags": [
"sectorc",
"программирование"
],
"author": {
"name": "Евгений Степанищев",
"url": "https:\/\/bolknote.ru\/",
"avatar": "https:\/\/bolknote.ru\/pictures\/userpic\/userpic@2x.jpg?1760600028"
},
"_date_published_rfc2822": "Sat, 17 Jun 2023 08:37:44 +0500",
"_rss_guid_is_permalink": "false",
"_rss_guid": "120446",
"_rss_enclosures": [],
"_e2_data": {
"is_favourite": false,
"links_required": null,
"og_images": []
}
},
{
"id": "120432",
"url": "https:\/\/bolknote.ru\/all\/div-in-sectorc\/",
"title": "Деление в SectorC",
"content_html": "
Очень неудобно, что в языке SectorC<\/i> нет деления. Я сначала думал, что это из-за ограничений — ведь задумка в том, чтобы компилятор помещался в сектор (512 байт). В таком случае можно было бы выкинуть операции левого и правого сдвига (<<<\/tt> и >><\/tt>), чтобы освободить место. Эти операции как раз можно было бы заменить умножением и делением.<\/p>\n
Но сегодня для интереса я попытался добавить в код новый токен для деления и оказалось, что места хватает. Закинул автору пулл-реквест, посмотрим примет ли. После моих изменений там осталось ещё шестнадцать байт, можно и ещё язык расширить.<\/p>\n
Впрочем, SectorC<\/i> устроен так, что в программе можно использовать машинные коды. Можно написать деление прямо в них, если воспользоваться ассемблером<\/a>.<\/p>\nПри этом надо знать две вещи: присваивание значения переменной происходит через регистр AX<\/tt>, так что присвоив переменную саму себе, можно записать в AX<\/tt> её значение, и второе — если посчитать atoi<\/tt> (см. мою вчерашнюю заметку<\/a>) для имени переменной и умножить получившееся число на два, можно получить ячейку, где хранится значение этой переменной.<\/p>\nТак вычисленный результат можно будет положить куда вздумается.<\/p>\n
Объединив всё вышесказанное, получим такой результат:<\/p>\n
int div_a; int div_b; \/\/ input\r\nint div_result;\r\n\r\nvoid div()\r\n{\r\n div_b = div_b; \/\/ mov ax, [&div_b]\r\n asm 145; \/\/ xchg cx, ax\r\n asm 49; asm 210; \/\/ xor dx, dx\r\n div_a = div_a; \/\/ mov ax, [&div_a]\r\n asm 247; asm 241; \/\/ div cx\r\n\r\n asm 163; asm 48; asm 193; \/\/ mov [&div_result], ax\r\n}\r\n\r\nvoid main()\r\n{\r\n div_a = 35500; div_b = 113; div();\r\n print_num = div_result; print_u16(); \/\/ «314»\r\n}<\/code><\/pre>",
"date_published": "2023-06-16T00:10:28+05:00",
"date_modified": "2023-06-17T08:07:35+05:00",
"tags": [
"sectorc",
"программирование",
"си"
],
"author": {
"name": "Евгений Степанищев",
"url": "https:\/\/bolknote.ru\/",
"avatar": "https:\/\/bolknote.ru\/pictures\/userpic\/userpic@2x.jpg?1760600028"
},
"_date_published_rfc2822": "Fri, 16 Jun 2023 00:10:28 +0500",
"_rss_guid_is_permalink": "false",
"_rss_guid": "120432",
"_rss_enclosures": [],
"_e2_data": {
"is_favourite": false,
"links_required": null,
"og_images": []
}
},
{
"id": "120405",
"url": "https:\/\/bolknote.ru\/all\/sectorcfuck\/",
"title": "SectorCFuck",
"content_html": "Очень интересно устроен разбор файла программы в компиляторе SectorC<\/i><\/a>, который я ковыряю вечерами из любви к ненормальному программированию. Для тех, кто успел позабыть, напомню — этот компилятор занимает один сектор (512 байт) и способен выполнять программу на подмножестве Си.<\/p>\nКогда смотришь на код такого маленького объёма, сразу возникает вопрос — каким чудом удалось туда запихнуть грамматику языка Си, даже если какое-то подмножество? Ответ — хеширование.<\/p>\n
Автор использует реализацию функции atoi<\/tt>, которая превращает любые строки в шестнадцатибитное числа:<\/p>\nunsigned short sectorc_atoi(const char *s)\r\n{\r\n unsigned short n = 0;\r\n for (;;) {\r\n char c = *s++;\r\n if (!c) break;\r\n\r\n n = 10 * n + (c - '0');\r\n }\r\n\r\n return n;\r\n}<\/code><\/pre>Все токены, которые встречаются в программе, обязательно разделяются пробелами (за исключением ;<\/tt>, для него есть специальная обработка). Это позволяет довольно просто парсить программу — любой токен скармливаем atoi<\/tt>, получаем число и по таблице смотрим с чем имеем дело.<\/p>\n
Если в таблице число не находится, значит это переменная, её численное значение, умноженное на два, даёт двухбайтовую область памяти, где надо взять значение. Для чисел, видимо, есть какая-то отдельная логика, я не читал подробно исходник, но из моих экспериментов как будто бы следует, что числом считается всё, что не токен и не может быть именем переменной.<\/p>\n
Перед запуском программа проходит через линтер, который не является частью компилятора. Он нужен для поиска ошибок в коде и коллизий в получившихся хешированных значениях. В последнем случае линтер останавливается с ошибкой, показывая хеши каких токенов совпали между собой.<\/p>\n
Если линтер выключить, можно достигнуть интересного эффекта. Для каждого токена можно вычислить коллизию позаковыристей и написать всю программу без букв и цифр. SectorC<\/i> как будто бы «из коробки» предназначен для запуска обфусцированного кода.<\/p>\n
Ниже программа, выводящая «Hello<\/i>» (её надо запускать без линтера<\/i>):<\/p>\n<**^ ')'|] \/=]\r\n -_.@" -[ )~( \/@< $^+>\\() \/<'\r\n -_.@" -[ \/<'' \/@< $^+>\\() \/<'\r\n -_.@" -[ ,[~ \/@< $^+>\\() \/<'\r\n -_.@" -[ +^^` \/@< $^+>\\() \/<'\r\n -_.@" -[ \/<(' \/@< $^+>\\() \/<'\r\n,[_<\/code><\/pre>Я поленился и не стал рассчитывать разные значения для одинаковых токенов, которые упоминаются несколько раз, но можно сделать и это, тогда восстановление исходного текста будет безумно затратной задачей.<\/p>\n
\n![\"\"](\"https:\/\/bolknote.ru\/pictures\/2023.06.14@2x.jpg\")
\nПример запуска обфусцированной программы без линтера<\/div>\n<\/div>\nОбфусцированный таким образом листинг, запускающий файл и программу для поиска коллизий выложил на «Гитхаб»<\/a>, можно посмотреть подробности там.<\/p>\nКстати, такое развлечение, когда мы не используем в программе алфавитно-цифровые символы, называется ЧтоНибудьFuck<\/i><\/a>, уж так повелось, — FuckJS<\/i>, FuckPHP<\/i> и так далее. Отсюда и название заметки.<\/p>\n",
"date_published": "2023-06-14T20:08:51+05:00",
"date_modified": "2023-06-15T23:54:51+05:00",
"tags": [
"*fuck",
"sectorc",
"программирование",
"си"
],
"author": {
"name": "Евгений Степанищев",
"url": "https:\/\/bolknote.ru\/",
"avatar": "https:\/\/bolknote.ru\/pictures\/userpic\/userpic@2x.jpg?1760600028"
},
"_date_published_rfc2822": "Wed, 14 Jun 2023 20:08:51 +0500",
"_rss_guid_is_permalink": "false",
"_rss_guid": "120405",
"_rss_enclosures": [],
"_e2_data": {
"is_favourite": false,
"links_required": null,
"og_images": []
}
},
{
"id": "120363",
"url": "https:\/\/bolknote.ru\/all\/svyortka-strok-na-sectorc\/",
"title": "Свёртка строк на SectorC (лонгрид)",
"content_html": "