К вопросу о защите программ

Delphi не для начинающих

Часть 1. Прячем формы

Как известно, многие рекомендации по совершенствованию программ, созданных с применением VCL, сводятся к простому указанию – открыть исполняемый модуль очередным Restorator’ом и поправить то или иное место в ресурсе формы или датамодуля. Наличие исходных текстов и какая-никакая документированность потоковой системы VCL привели к тому, что сегодня извлечение в читабельное представление и обратная запись содержимого ресурсов форм не является задачей, посильной только усилиям гуру.

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

1. СОЗДАНИЕ ФИЛЬТРА ЧТЕНИЯ ДАННЫХ

Итак, единственное место во всем VCL, где происходит доступ к ресурсу формы – это функция InternalReadComponentRes из Classes, текст которой приведен ниже:
function InternalReadComponentRes(
    const ResName: string;
    HInst: THandle;
    var Instance: TComponent
): Boolean;
var
    HRsrc: THandle;
begin        { avoid possible EResNotFound exception }
    if HInst = 0 then HInst := HInstance;
    HRsrc := FindResource(HInst, PChar(ResName), RT_RCDATA);
    Result := HRsrc <> 0;
    if not Result then Exit;
    with TResourceStream.Create(HInst, ResName, RT_RCDATA) do
    try
        Instance := ReadComponent(Instance);
    finally
        Free;
    end;
    Result := True;
end;

Суть ее действий несложна: в модуле, определяемом параметром HInst, ищем ресурс с типом RCDATA и заданным именем. Если не находим, то возвращаем False и на этом успокаиваемся, иначе создаем поток на данных указанного ресурса и читаем из него данные методом ReadComponent.

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

type
    TLoadComponentFunc = function (hInst: THandle;
      const ResName: string;
      var Instance: TComponent): Boolean;

var
    LoadComponentFunc: TLoadComponentFunc;

а в implementation мы изменим функцию InternalReadComponentRes следующим образом:

function InternalReadComponentRes(
      const ResName: string;
      HInst: THandle;
      var Instance: TComponent): Boolean;
var
    HRsrc: THandle;
begin        { avoid possible EResNotFound exception }
    if HInst = 0 then HInst := HInstance;
    if not Assigned(LoadComponentFunc) then
    begin
        HRsrc := FindResource(HInst, PChar(ResName), RT_RCDATA);
        Result := HRsrc <> 0;
        if not Result then Exit;
        with TResourceStream.Create(HInst, ResName, RT_RCDATA) do
        try
            Instance := ReadComponent(Instance);
        finally
            Free;
        end;
        Result := True;
    end else Result := LoadComponentFunc(HInst, ResName, Instance);
end;

Легко увидеть, что TLoadComponentFunc по описанию совпадает с InternalReadComponentRes и вызывается внутри нее, выступая в качестве того самого «клина», о котором мы и говорили выше. Описание TLoadComponentFunc и переменную, содержащую адрес обработчика мы добавляли в самом конце interface-секции Classes с единственной целью – избежать таких изменений в модуле, которые приводили бы к печально известному сообщению (“Unit xxx was compiled with another version of yyy”). Практика свидетельствует, что дописывание каких-либо новых определений в конец существующего модуля никак не влияет на «версионную отметку» вышестоящих описаний (подробнее об этом в другой раз, пока придется поверить на слово).

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

Пример модуля, реализующего фильтр, тождественный VCL-ному чтению:

unit DFMLoader;

interface

uses
Classes; // Classes должны быть измененными!

implementation

uses
    Windows;

function MyLoadFunc(
    HInst: THandle;
    const ResName: string;
    var Instance: TComponent
): Boolean;
begin
    with TResourceStream.Create(HInst, ResName, RT_RCDATA) do
    try
        Instance := ReadComponent(Instance);
    finally
        Free;
    end;
    Result := True;
end;

initialization
    LoadComponentFunc := @MyLoadFunc;

finalization
    LoadComponentFunc := nil;
end.

Обратим внимание на initialization и finalization. Установка фильтра помещена в initialization с тем, чтобы для активизации нашего метода защиты было достаточно просто подключить модуль к проекту. Изъятие фильтра на finalization обусловлено тем, что при использовании пакетов (packages) обращение к фильтру происходит внутри VCLXX.BPL (или RTLXX.bpl в D6), а сам фильтр располагается в другом пакете, который может быть выгружен. Именно поэтому на выходе мы и уберем за собой.

Лирическое отступление: в процессе тестирования описываемой защиты первоначально зануление фильтра отсутствовало, но быстро появилось после эффектного падения IDE на перекомпиляции модуля с защитой ;-) Кстати, IDE могло упасть только после перекомпиляции VCLXX/RTLXX, но о том, как это делалось, тоже не в этот раз.

2. РЕАЛИЗАЦИЯ ФИЛЬТРА

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

При этом обратим внимание, что начало данных ресурса формы обозначено сигнатурой “TPF0”, а после нашего преобразования там будет “UQG1” (вместо каждого символа сигнатуры мы взяли следующий за ним по таблице ASCII). Мы используем это обстоятельство для решения вопроса о том, каким образом читать ресурс.

Итак, функция чтения ресурса теперь будет выглядеть так:

function MyLoadFunc(
    HInst: THandle;
     const ResName: string;
     var Instance: TComponent
): Boolean;
const
    MySignature: array[0..3] of Char = 'UQG1';
var
    I: Integer;
    HRsrc: THandle;
    src: TResourceStream;
    Stream: TMemoryStream;
begin
    HRsrc := FindResource(HInst, PChar(ResName), RT_RCDATA);
    Result := HRsrc <> 0;
    if not Result then Exit;

    src := TResourceStream.Create(HInst, ResName, RT_RCDATA);
    try
        if LongInt(src.Memory^) = LongInt(MySignature) then
        begin
            Stream := TMemoryStream.Create;
            try
                Stream.LoadFromStream(src);
                { расшифровываем }
                for I := 0 to Stream.Size - 1 do
                    Dec(Byte(PChar(Stream.Memory)[I]));
                { и загружаем }
                Instance := Stream.ReadComponent(Instance);
            finally
                Stream.Free;
            end;
        end else Instance := src.ReadComponent(Instance);
    finally
        src.Free;
    end;
    Result := True;
end;

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

program protect;

{$APPTYPE CONSOLE}

uses
    Windows, Classes;

const
    FormSignature: array[0..3] of Char = 'TPF0';

function MyEnumProc(hModule: THandle; lpResType, lpResName: PChar;
    lParam: LPARAM): BOOL; stdcall;
var
    I: Integer;
    Src: TResourceStream;
    Dst: TMemoryStream;
begin
    if DWORD(lpResName) and $FFFF0000 <> 0 then
    begin
        Src := TResourceStream.Create(hModule, lpResName, lpResType);
        try
        { удостоверимся, что это именно ресурс формы! }
            if LongInt(Src.Memory^) = LongInt(FormSignature) then
            begin
                Dst := TMemoryStream.Create;
                try
                    Dst.LoadFromStream(Src);
                    Dst.Position := 0;

                    { зашифруем }
                    for I := 0 to Dst.Size - 1 do
                    Inc(Byte(PChar(Dst.Memory)[I]));

                    TStrings(lParam).AddObject(lpResName, Dst);
                except
                    Dst.Free;
                    raise;
                end;

        finally
            Src.Free;
        end;
    end;
    Result := True;
end;

procedure GetResNames(const Filename: string; Items: TStrings);
var
    hModule: THandle;
begin
    hModule := LoadLibraryEx(PChar(Filename), 0, LOAD_LIBRARY_AS_DATAFILE);
    if hModule <> 0 then
    try
        EnumResourceNames(hModule, RT_RCDATA, @MyEnumProc, LPARAM(Items));
    finally
        FreeLibrary(hModule);
    end;
end;

procedure UpdateResources(const Filename: string; Items: TStrings);
var
    I: Integer;
    Stream: TMemoryStream;
    hUpdate: THandle;
begin
    hUpdate := BeginUpdateResource(PChar(Filename), False);
    if hUpdate <> 0 then
    try
        for I := 0 to Items.Count - 1 do
        begin
            Stream := Items.Objects[I] as TMemoryStream;
            UpdateResource(hUpdate, RT_RCDATA, PChar(Items[I]), 0, Stream.Memory, Stream.Size);
        end;
    finally
        EndUpdateResource(hUpdate, False);
    end;
end;

var
    I: Integer;
    Items: TStrings;
begin
    Items := TStringList.Create;
    try
        GetResNames(ParamStr(1), Items);
        UpdateResources(ParamStr(1), Items);
    finally
        { освободим временные буфера }
        for I := 0 to Items.Count - 1 do
            Items.Objects[I].Free;
        Items.Free;
    end;
end.

Что мы здесь делаем: во-первых, загружаем обрабатываемый исполняемый модуль и находим в нем все ресурсы с данными от форм (обращая внимание на то, чтобы это были именно данные форм путем проверки сигнатуры). Преобразованные копии этих ресурсов вместе с именами мы складываем в список.

Затем мы освобождаем модуль и открываем его уже для изменения ресурсов (одновременно произвести два открытия нам не дадут). Т.к. нам известны имена, типы и содержимое обновляемых ресурсов, ничто не мешает нам заменить ресурсы и, запустив программу, убедиться, что все работает. Осмотр же с использованием Restorator’а более не выявляет внутри программы каких-либо форм. Что и требовалось доказать.

3. ЧТО ОСТАЛОСЬ ЗА КАДРОМ

Во-первых, обработка большинства ошибок. Например, отсутствие на диске исходного файла в защищалке. Или более тщательная проверка целостности и корректности информации в шифрованных ресурсах. Для описания концепции приведенной информации вполне достаточно, а при развитии идеи появятся иные места для проверки.

Во-вторых, системная функция обновления ресурсов в файле есть только в WinNT/2K/XP. Однако для целей защиты всегда можно найти машину с указанными ОС или, перелопатив MSDN, написать полностью свое обновление ресурсов.

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

В-четвертых, диапазон возможностей, которые открываются в описанном подходе, не ограничивается только преобразованием ресурсов. В фильтре вполне возможно реализовать чтение данных через Интернет. Ну или хотя бы преобразовать их через установленный электронный ключ… Или в самом простом случае, упаковать их каким-либо алгоритмом (zLib, к примеру).

4. ЗАКЛЮЧЕНИЕ

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

Особая изюминка заключается в сложности написания универсальной «открывашки» для ресурсов – даже если для версии N Вашей программы определили алгоритм восстановления ресурсов, в версии N+1 Вы незначительно изменяете алгоритм и делаете бесполезной предыдущий хакерский труд.

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

А что же в минусе: необходимость модифицировать исходный текст VCL и поддерживать затем эти изменения при переходе к новым версиям или установки UpdatePack’ов, но это и в самом деле не так страшно, как может показаться. Во всяком случае, за те пять лет, что применяется описанный метод, это никогда не составляло серьезной проблемы.