Крупные производители тиражного программного обеспечения отказались от защиты своих продуктов, сделав ставку на их массовое распространение. Пусть лицензионные копии приобретает лишь несколько процентов пользователей, но, если число этих копий измеряется миллионами, даже считанные проценты выливаются в солидную сумму, с лихвой окупающую разработку. Однако для небольших коллективов и индивидуальных программистов такая тактика неприемлема. Им необходимо предотвратить «пиратское» копирование своего продукта.

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

Противодействие изучению исходных текстов

Вообще говоря, открытость исходных текстов — понятие расплывчатое. Автор статьи [1] справедливо задается вопросом: «Является ли бинарная программа в 1 Kбайт более открытой, чем миллион строк исходников без адекватной инфраструктуры и документации?» В самом деле, мало иметь исходный текст — в нем еще предстоит разобраться. Достаточно удалить все или, по крайней мере, большую часть комментариев, дать переменным и функциям бессмысленные, ничего не говорящие имена, как в программе не разберется и сам автор. А наличие и полнота комментариев к исходному тексту в контракте, как правило, не оговаривается. Получается, что контракт может быть формально выполнен, а предоставленный заказчику исходный текст практически бесполезен. «Практически» не означает «полностью»: такой простой прием не позволит обеспечить абсолютную защиту.

Воспрепятствовать анализу можно отделением, абстрагированием алгоритма от языка реализации. Например, реализовать критичные для раскрытия компоненты на машине Тьюринга [2], а ее поддержку обеспечить на целевом языке. Уровней абстракции может быть несколько — чем их больше, тем труднее осуществлять анализ. Помимо машины Тьюринга для этой цели подходят стрелка Пирса, сети Петри и т.д. Такой подход дает превосходный результат, но требует глубоких математических знаний и значительных накладных расходов — программировать на машине Тьюринга намного сложнее, чем на ассемблере. (Отдельный вопрос — эффективность полученной программы. — Прим. ред.) Для многих проектов это неприемлемо, поэтому приходится использовать другие приемы.

Динамическое ветвление

Программу, состоящую из нескольких сотен тысяч строк, невозможно рассматривать как простую совокупность команд. На таком уровне детализации «за деревьями леса не видно». Сначала необходимо проанализировать взаимосвязь отдельных функций друг с другом, выделить интересующие фрагменты и лишь затем изучать реализацию самих функций. Чем выше степень дробления программы, тем труднее анализ. Элементарные функции, состоящие из десятка строк, сами по себе дают мало информации. Для формирования целостной картины необходимо рассмотреть вызывающий их код, поднимаясь по иерархии вызовов до тех пор, пока не удастся реконструировать весь алгоритм целиком или, по крайней мере, охватить его ключевой фрагмент. Чтобы построить дерево вызовов, нужно уметь отслеживать перекрестные ссылки в обоих направлениях: определять, какой функции передается управление данным вызовом, и, наоборот, находить все вызовы, передающие управление данной функции.

Этому легко воспрепятствовать, воспользовавшись динамическим ветвлением — т.е. вычислением адреса перехода непосредственно перед передачей управления. Если функция возвращает не результат своей работы, а указатель на следующую выполняемую функцию (результат работы можно возвратить через аргументы, переданные по ссылке), то статический анализ не позволит определить порядок выполнения программы и построить дерево вызовов станет невозможно. Попутно исчезнет масса дублируемого кода, в частности, станет ненужной проверка результата завершения на корректность — в случае возникновения ошибки функция сама передаст управление нужной ветви программы.

Здесь стоит сделать одну оговорку. Язык Си не позволяет объявить функцию, возвращающую указатель на функции — это объявление рекурсивное. Приходится объявлять функцию, возвращающую бестиповой указатель void *. Аналогично — если функция в ходе своей работы вызывает какие-то другие функции, лучше делать это не напрямую, а передавать указатели на вызываемые функции как аргументы. Такой подход не только препятствует анализу, но еще и увеличивает гибкость программы, облегчая повторное использование старого кода в новых проектах - при должной культуре программирования каждая функция представляет «вещь в себе» и не привязана ко всем остальным.

Контекстная зависимость

Рассмотрим теперь другой прием, когда алгоритм работы большинства функций зависит от флага — глобальной переменной в пределах одного модуля. Если флаги изменяются в зависимости от результата, возвращаемого функцией, автоматически возникает контекстная зависимость (не слишком сильная, но это лучше, чем ничего). Работа одной функции становится зависимой от других, вызванных до нее. Анализ одной, отдельно взятой функции, становится многовариантным. Чтобы определить, что конкретно она делает, необходимо знать значение флагов, а значит — иметь представление о том, какие функции выполнялись до этого и какие именно данные они обрабатывали.

Опять замечание: в многопоточной среде глобальный флаг можно использовать только в том случае, если все потоки явно синхронизованы; в противном случае необходимо предоставить каждому потоку свой собственный экземпляр флага. Глобальный флаг требует особого внимания, малейшая небрежность приводит к трудноуловимым ошибкам. Разобраться в программе с множеством одновременно выполняемых потоков, манипулирующих с одной переменной, невероятно трудно; малейшая невнимательность или излишняя торопливость приводят к ошибкам анализа, затрудняющим понимание сути алгоритма.

Хуки

Хуки («крючья») — изящный, но ныне практически забытый прием программирования. Его суть заключается в совмещении нескольких разнотипных данных в одном аргументе. Например, если значение аргумента по модулю меньше 0x400000, функция считает его непосредственным значением, в противном случае — указателем на функцию, результат выполнения которой следует поставить на его место. Это увеличивает гибкость программы, но и затрудняет ее анализ, не позволяя быстро определить, происходит ли передача переменной по значению или по указателю. Указатели на переменную, в свою очередь, становятся неотличимы от указателей на функцию. Разумеется, отказ от строгой типизации может приводить к ошибкам, но вероятность их появления в тщательно продуманной программе невелика.

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

Существует еще множество других способов запутать того, кто пытается проанализировать исходный текст. Например, можно использовать совершенно корректные с точки зрения языка, но необычные конструкции, ставящие в тупик незнакомого с ними человека. Классический пример — перестановка индекса и имени массива в Си. С точки зрения языка, выражения «buff[666]» и «666[buf]» абсолютно равнозначны, но всякий ли об этом помнит?

Препроцессор Си также имеет свои тонкости. Возможно, самая популярная из них заключается в чувствительности к пробелам при объявлении макроса: «#define x(a,b) a+b» создаст макрос x(a,b), заменяющийся суммой своих аргументов, но «#define x (a,b) a+b» создаст макрос x, заменяющийся последовательностью «(a,b) a+b». Если не обратить внимание на лишний пробел, можно получить совсем не тот результат.

В той или иной степени эти, а также другие приемы используются в большинстве свободно распространяемых «открытых текстов». Последнее словосочетание заключено в кавычки для придания ему ироничного оттенка: одно лишь наличие исходного текста еще не обеспечивает открытости, — требуется, по меньшей мере, грамотно продуманная и качественно составленная документация, а еще лучше — опыт работы с этим текстом. Разобраться с исходными текстами редактора emacs или операционной системы Linux не намного проще, чем написать их «с нуля», — слишком уж скупы их разработчики на комментарии, а документация зачастую и вовсе отсутствует.

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

Противодействие анализу двоичного кода

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

Сегодня трудоемкость анализа двоичного кода не настолько велика, чтобы надолго остановить злоумышленников. Огромное число постоянно совершаемых взломов — лучшее тому подтверждение. В идеальном случае знание алгоритма защиты не должно влиять на ее стойкость, но это достижимо далеко не всегда. Например, если производитель серверной программы решит установить в демонстрационной версии ограничение на количество одновременно обрабатываемых соединений, злоумышленнику достаточно найти инструкцию процессора, осуществляющую такую проверку и удалить ее. Модификации программы можно воспрепятствовать постоянной проверкой контрольной суммы, но опять-таки код, который вычисляет эту контрольную сумму и сверяет ее с эталоном, можно найти и удалить.

Сколько бы уровней защиты не предусмотреть, один или миллион, программа может быть взломана — это только вопрос времени и затраченных усилий. Но в отсутствии действенных правовых регуляторов защиты интеллектуальной собственности разработчикам приходится больше полагаться на стойкость своей защиты, чем на закон. Бытует мнение, что если затраты на нейтрализацию защитного механизма будут не ниже стоимости легальной копии, ее никто не будет взламывать. Это неверно. Материальный стимул — не единственное, что движет хакером. Гораздо более сильной мотивацией оказывается интеллектуальная борьба с автором защиты, спортивный азарт, любопытство, повышение своего профессионализма, да и просто интересное времяпровождение. Многие молодые люди могут неделями корпеть над отладчиком, снимая защиту с программы стоимостью в несколько долларов, а то и вовсе распространяемой бесплатно (например, диспетчер файлов FAR для жителей России абсолютно бесплатен, но это не спасает его от взлома).

Тем не менее, есть опыт создания защит, сломать которые почти невозможно. (Точнее, их взлом потребовал бы многих тысяч, а то и миллионов лет на типичном бытовом компьютере.)

Гарантированно воспрепятствовать анализу кода позволяет только шифрование программы. Но сам процессор не может непосредственно исполнять зашифрованный код, поэтому перед передачей управления его необходимо расшифровать. Если ключ содержится внутри программы, стойкость такой защиты близка к нулю. Все, чего может добиться разработчик, — затруднить поиск и получение этого ключа, тем или иным способом препятствуя отладке и дизассемблированию программы. Другое дело, если ключ содержится вне программы. Тогда стойкость защиты определяется стойкостью используемого криптоалгоритма (конечно, при условии, что ключ перехватить невозможно). Опубликованы и детально описаны многие криптостойкие шифры, взлом которых заведомо недоступен рядовым злоумышленникам.

В общих чертах идея защиты заключается в описании алгоритма с помощью некой математической модели, одновременно с этим используемой для генерации ключа. Разные ветви программы зашифрованы различными ключами, и чтобы вычислить этот ключ, необходимо знать состояние модели на момент передачи управления соответствующей ветви программы. Код динамически расшифровывается в процессе выполнения, а чтобы расшифровать его целиком, нужно последовательно перебрать все возможные состояния модели. Если их число будет очень велико (этого нетрудно добиться), восстановить весь код станет практически невозможно.

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

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

Алгоритм шифрования должен быть выбран так, чтобы обратная операция была невозможна. При этом установить, какое событие данный обработчик обрабатывает, можно только полным перебором. Для блокирования возможности перебора в язык была введена контекстная зависимость — генерация дополнительной серии ключей, учитывающих некоторое количество предыдущих событий. Это позволило устанавливать обработчики на любые последовательности действий пользователя, например, на открытие файла с именем «Мой файл», запись в него строки «Моя строка» и переименование его в «Не мой файл».

Очевидно, перебор комбинаций всех событий со всеми возможными аргументами займет бесконечное время, а восстановить исходный код программы, защищенной таким образом, удастся не раньше, чем все ее ветви хотя бы однократно получат управление. Однако частота вызова различных ветвей не одинакова, а у некоторых и вовсе очень мала. Например, можно установить на слово «сосна», введенное в текстовом редакторе, свой обработчик, выполняющий некоторые дополнительные проверки на целостность кода программы или на лицензионную чистоту используемого ПО. Взломщик не сможет быстро выяснить, до конца ли взломана программа или нет. Ему придется провести тщательное и кропотливое тестирование, но даже после этого он не будет в этом уверен.

Таким же точно образом осуществляется ограничение срока службы демонстрационных версий. Разумеется, обращаться к часам реального времени бесполезно, их очень легко перевести назад, вводя защиту в заблуждение. Гораздо надежнее опираться на даты открываемых файлов: даже если часы переведены, созданные другими пользователями файлы в большинстве случаев имеют правильное время. Но взломщик не сможет узнать ни алгоритм определения даты, ни саму дату окончания использования продукта. Впрочем, дату в принципе можно найти и полным перебором, но что это дает? Модификации кода воспрепятствовать очень легко: достаточно, чтобы длина зашифрованного текста была чувствительна к любым изменениям исходного. В этом случае взломщик не сможет подправить «нужный» байт в защитном обработчике и вновь зашифровать его. Придется расшифровывать и вносить изменения во все остальные обработчики (при условии, что они контролируют смещение, по которому расположены), а это невозможно, поскольку соответствующие им ключи заранее неизвестны.

Существенными недостатками предлагаемого решения являются низкая производительность и высокая сложность реализации. Если со сложностью реализации можно смириться, то скорость налагает серьезные ограничения на сферу применения. Впрочем, можно значительно оптимизировать алгоритм или оставить все критичные к быстродействию модули незашифрованными (или расшифровывать каждый обработчик только один раз). Интересно другое: действительно ли эта технология позволяет создавать принципиально неизучаемые приложения или в приведенные рассуждения вкралась ошибка? Было бы интересно выслушать мнения коллег, специализирующихся на защите информации.

Заключение

Целесообразность защиты исходных текстов ограничивается конкурентной борьбой — при прочих равных условиях клиент всегда выбирает незащищенный продукт, даже если защита не ущемляет его прав. Сегодня спрос на программистов превышает предложение, но в отдаленном будущем тенденция изменится и разработчикам придется либо сговориться, либо полностью отказаться от защит, а специалисты по защите будут вынуждены искать себе другую работу. Это не значит, что данная статья бесполезна. Напротив, полученные знания целесообразно применять, не откладывая, пока в защите исходных текстов еще не отпала необходимость.

Литература

[1] Николай Безруков, «Разработка программ с открытыми исходниками как особый вид научных исследований», http://firstmonday.org/issues/issue4_10/ bezroukov/index.html

[2] Манфред Брой, «Информатика. Основополагающее введение. Структуры систем и системное программирование. Часть III» // М.: Диалог-МИФИ, 1996

Крис Касперски (kk@sendmail.ru) — независимый консультант.

Три ключа

Три ключа необходимы для отказа от явной проверки значения аргументов, которую легко обнаружить анализирующему лицу. Например, пусть событие KEY (key_code) генерируется при каждом нажатии клавиш. Тогда обработчик, считывающий входную информацию, должен привязываться только к коду события (KEY) и получать введенный символ в виде аргумента. Если одна из клавиш или их комбинация зарезервирована для специальной цели (например, задействует некоторые дополнительные функции в программе), то ее обработчик может привязываться одновременно к коду события (KEY) и коду клавиши (key_code), не опасаясь за свое раскрытие, так как правильный ключ дает лишь единственная комбинация KEY и key_code, а явная проверка на соответствие нажатого символа секретному коду отсутствует.

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