IT-Блог о программировании и операционных системах

Материалы, которые ожидаются в июне месяце

3 комментария:

3dhelmet57

Здравствуйте уважаемые посетители нашего информационного Delphi-блога!

Составил для себя небольшой план, которому постараюсь придерживаться в этом месяце. По моему, это очень удобно, когда есть определённый намеченный план. Это лучше чем каждый раз думать и вспоминать, какие материалы подготовить, какие отпостить, отредактировать и т.д. По большому счёту – этот план примерный, так что не исключаются изменения (но я думаю надеюсь, это будут скорее дополнения). Как всегда, материал попытается быть для вас интересным, так что, если вы всё ещё не подписались на RSS-новости, не откладывайте это дело. Итак…

  • Защита ваших Delphi-приложений от взлома (а так же их взлом глазами реверс инженера)
  • Избитая, но всё ещё больная тема или размер Delphi-приложения
  • Тематические форумы, сообщества и группы. А были ли специалисты?
  • Работа с PE-файлами в Delphi.
  • Компонента для работы с PE-файлами.
  • Уроки по Delphi для новичков (не уверен, нужно ли… Буду думать. Комментарии?)
  • Флеш-уроки по Olly (Лень, но подумаю…)

Пожалуй хватит на июнь, хотя сомневаюсь конечно, что и это успею. Но, терпение и труд - всё перетрут. Рад буду услышать ваши комментарии. До встречи!

Чего мне не хватает в Delphi

8 комментариев:
Недавно комментировал пост Алексея Тимохина на одноимённую тему и понял, что есть определённые вещи, которые бы не помешали мне в Delphi. Итак, я начну:
  • Хотелось бы иметь возможность задавать значение выравнивания программных секций. Всё таки моя программа – хочу будет 2, а захочу 256. Да и нафиг мне куча ненужных мне нулей?
  • Хотелось бы иметь возможность замены штатного стаба в компилированных программах. Мелочь, а приятно.
  • Как я уже писал в своем комментарии на блоге Алексея, было бы очень неплохо, если бы Delphi сама могла проверять целостность себя и своих файлов. Это бы разом решило все проблемы с подобного рода вещами.
  • Хотелось бы иметь в палитре компонентов переключалку, которая бы позволяла вводить не начальное имя искомого компонента, а любые символы последовательно встречающиеся в имени. (Реализовано в 2009. Реализовано в Delphi 2010, может быть и раньше, но по 2006 включительно - нет. Спасибо Александру Алексееву за комментарий. )
  • К предыдущему неплохо бы переключалку, позволяющею вводить имя вкладки, на которой этот компонент висит. Я например, часто помню только название вкладки.
Хотелки других Delphi-разработчиков:

P.S. Хочу ещё, чтобы войны не было

О вложенных подпрограммах в Delphi

5 комментариев:

Доброго времени суток, дорогие читатели. Данная заметка может быть не очень большая, но тем не менее, довольно информативная. В ней я расскажу о такой полезной возможности языка Delphi, как вложенные процедуры и функции (далее автор подразумевает, что значения слов “процедура” и “функция” одинаковы. Для удобства и по привычке). На самом деле, многие программисты Delphi знают, что такая возможность в языке есть, но вот используют ее единицы. Скажу больше – многие так называемые NewSchool Delphi-программисты вообще не имеют представления, что существует подобный вид подпрограмм.

Внедрение своей DLL в среду Delphi

7 комментариев:

Данная заметка, является логическим продолжением предыдущего материала по расширению возможностей IDE. На этот раз мы внедрим в среду свою DLL-библиотеку. Для чего это можно применить? Хороший вопрос! Если честно – я пока и сам не знаю. Но надеюсь, что по мере написания данного материала, некая шальная мысля ударит в мою голову. А пока, давайте будем расценивать данную статью просто как очередную авторскую заметку, с его мыслями и соображениями. Итак, как всё будет происходить? Мы напишем некую DLL, которая будет выполнять некие полезные (?) действия, перед стартом среды.

Итак, первым делом нам нужно написать саму библиотеку. Я долго не мог придумать, что такого полезного она будет делать и моей фантазии хватило только на то, чтобы она позволяла нам выбирать, какие мастера загружать вместе со средой. То есть, перед стартом среды, появляется некое окно, в котором мы можем выбирать, какие визарды загружать, а какие нет. Это может пригодиться например при разработке подобных мастеров, вернее во время их отладки. Например если какой либо новый визард будет пестрить ошибками во время загрузки IDE, тем самым не давая ей нормально работать – мы сможем его отключить, очень удобным образом.

Расширяем возможности Delphi / Builder IDE

6 комментариев:
В данной заметке, хочу поделиться с вами хорошим примером написания модуля, с помощью которого можно добавить новые возможности в вашу Delphi IDE.
Пример из этой статьи довольно простой, но между тем и очень эффективный. Он позволяет очень легко добавить обработчик события (назовём его обработчиком нажатия средней кнопки мыши), в среду Delphi, путём обработки сообщений Windows.
Пусть, для примера, в обработчике будет выполняться код, отвечающий за программное нажатие клавиши F12, тем самым позволяя нам переключаться между окнами исходного кода и дизайнера форм по средней кнопке мыши. Очень удобно, правда?
unit WinSwap;
interface
uses
Windows, Messages, SysUtils, Classes, Controls, Forms;

type
  TWinSwap = class(TObject)
    private
      fIDE:TApplication;
      procedure PressKey(Key:Word);
    protected
      procedure IDEMessage(var Msg: TMsg; var Handled: Boolean);
    public
      property IDE:TApplication read fIDE write fIDE;
  end;

var
  oSwaper: TWinSwap;

implementation

procedure SwapInit;
begin
  { связываем поле fIDE со средой Delphi }
  oSwaper.IDE := Application;
  { устанавливаем новый обработчик OnMessage }
  oSwaper.IDE.OnMessage := oSwaper.IDEMessage;
end;

{ TWinSwap }
procedure TWinSwap.IDEMessage(var Msg: TMsg; var Handled: Boolean);
begin
  if IDE.Active then
    begin
      if Msg.Message = WM_MBUTTONUP then
      PressKey(VK_F12);
    end
  else
    Exit;
end;

procedure TWinSwap.PressKey(Key: Word);
begin
  keybd_event(Key,0,KEYEVENTF_EXTENDEDKEY,0);
  keybd_event(Key,0,KEYEVENTF_EXTENDEDKEY or KEYEVENTF_KEYUP,0);
end;

initialization
  oSwaper := TWinSwap.Create;
  { инициализируем расширение }
  SwapInit;

finalization
  { скидываем обработчик }
  oSwaper.IDE.OnMessage := nil;
  oSwaper.Free;
end.
Как видите, код не самый сложный и разобраться в нём не составит никакого труда. Ключевые строки располагаются в процедуре SwapInit. Происходит присвоение значения объекта Application (которое рассматривается как объект самой среды) полю fIDE типа TApplication и затем устанавливаем новый обработчик OnMessage уже самой IDE.
Таким образом можно обрабатывать многие полезные сообщения, приходящие из вне. Можно работать с отдельными частями IDE как с простыми компонентами, средствами объекта Application.  Вообщем можно много всего, главное приложить немного фантазии, которой у меня к сожалению не много.

Установка

Установка такого модуля сводится к обычной инсталляции нового компонента в новый, или существующий пакет. Другими словами, установка такого модуля и нового компонента ничем не отличается.
Надеюсь, этот пример был полезен для вас. С наилучшими пожеланиями. Читайте новые интересные заметки на страницах блога Delphi Day.

Правильная версия


Если вы прочитаете комментарии ниже, поймете, что данная версия кода мягко говоря не очень правильная. Как я там написал, что:


Если написать ещё один подобный (компонент?, даже не знаю как правильно назвать) модуль. То при его инициализации, обработчик OnMessage как бы перекроет обработчики всех остальных, инсталлированых до него, что собственно одно и тоже (с небольшими поправками), о чём говорил USoft.

Я немного дополнил код, следуя совету USoft. Проверял на 10ти таких установленных в систему расширений. Теперь всё работает прекрасно. Испытания проводил в двух средах: D7, D2k6.
Хотел бы отдельно поблагодарить Алексея Тимохина за расшифровку совета USoft и USoft'a, за дельный совет. Спасибо, коллеги.
 Итак, правильная версия скорее всего должна быть такая:



unit WinSwap;
interface
uses
Windows, Messages, SysUtils, Classes, Controls, Forms;

type
  TIDEHandler = procedure (var Msg:TMsg; var Handled: Boolean) of object;
  TWinSwap = class(TObject)
    private
      fIDE:TApplication;
      fIDEHandler:TIDEHandler;
      procedure PressKey(Key:Word);
    protected
      procedure IDEMessage(var Msg: TMsg; var Handled: Boolean);
      procedure BuffHandler;
    public
      property IDE:TApplication read fIDE write fIDE;
      property Handler:TIDEHandler read fIDEHandler write fIDEHandler;
  end;

var
  oSwaper: TWinSwap;

implementation

procedure SwapInit;
begin
  { связываем поле fIDE со средой Delphi }
  oSwaper.IDE := Application;
  oSwaper.BuffHandler;
  { устанавливаем новый обработчик OnMessage }
  oSwaper.IDE.OnMessage := oSwaper.IDEMessage;
end;

{ TWinSwap }
procedure TWinSwap.BuffHandler;
begin
  Handler := oSwaper.IDE.OnMessage;
end;

procedure TWinSwap.IDEMessage(var Msg: TMsg; var Handled: Boolean);
begin
  if IDE.Active then
    begin
      if Msg.Message = WM_MBUTTONUP then
        PressKey(VK_F12);
      Handler(Msg,Handled);
    end
  else
    begin
      Handler(Msg,Handled);
      Exit;
    end;
end;

procedure TWinSwap.PressKey(Key: Word);
begin
  keybd_event(Key,0,KEYEVENTF_EXTENDEDKEY,0);
  keybd_event(Key,0,KEYEVENTF_EXTENDEDKEY or KEYEVENTF_KEYUP,0);
end;

initialization
  oSwaper := TWinSwap.Create;
  { инициализируем расширение }
  SwapInit;

finalization
  { скидываем обработчик }
  oSwaper.IDE.OnMessage := nil;
  oSwaper.Free;
end.

Отладка Delphi-приложений в OllyDbg

14 комментариев:
Отличная всё таки вещь – привычка. Нет, я не про вредные привычки говорю, не переживайте, я имею ввиду правильные, профессиональные привычки. Пить и курить безусловно вредно, а вот использовать совместно прекрасные программные средства – нисколько, одна только польза. Почему именно в Olly, если есть прекрасный интегрированный в среду Delphi отладчик? Нет, друзья мои, я не пытаюсь сказать, что штатный отладчик плох, или не справляется со своими обязанностями, ни в коем случаи, просто, это дело привычки. И чтоб меня десять раз ударили томом Кнутта, если я такой один. И действительно, отладчик Olly приобрёл большую популярность как среди программистов, так и среди любителей покопаться в кишках некой платной утилиты. Ещё бы: куча возможностей, удобство использования, куча плагинов в конце концов, всё это делает отладчик Olly прекрасным инструментом для любого мало-мальски профессионального разработчика. Так же скажу, что данная заметка больше будет интересна тем программистам, которые не используют OllyDbg, но хотели бы познакомиться с этим инструментом поближе.
Предвкушаю шквал вопросов, летящих в мою сторону. Как нам, Delphi разработчикам отлаживать программу, если эта Olly просто пестрит ассемблерными инструкциями! Где наш нормальный паскалевский код? Секундочку! А разве в дельфовом отладчике нет окна CPU, с такими-же инструкциями? Есть. Да и окошко с нормальным исходником там тоже имеется, его просто нужно включить. Как, читаем дальше.

Пользовательские события для начинающих

2 комментария:
У новичков зачастую возникает проблема, создание собственных событий, отличных от событий Windows. Примером таких событий может быть, изменение каких-то данных, запуск какого-то метода и т.д. Delphi предлагает довольно простое и понятное решение для такого рода задач.

А теперь посмотрим как это делается. Создадим новое приложение и отдельный модуль uTest.
В этом модуле, создадим свой класс, который будет реализовывать хранение какой то текстовой информации.

TTextClass = class
  private
    FData: string
    procedure SetData(const Value: string);
  public
    property Data: string read FData write SetData;
end;

Теперь объявим класс-события:

TTextNotify = procedure(Sender: TObject; Text: string) of object;

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

Теперь объявим события, которые будут реагировать на 2 события:
- До редактирования текста
- После редактирования текст

TTextClass = class  
  private  
    FAfterSetText: TTextNotify;  
    FBeforeSetText: TTextNotify;  
    FData: string;  
    procedure SetData(const Value: string);  
  public  
    property Data: string read FData write SetData;  
    property BeforeSetText: TTextNotify read FBeforeSetText write FBeforeSetText;  
    property AfterSetText: TTextNotify read FAfterSetText write FAfterSetText;  
  end;

Ну а теперь осталось только написать вызовы данных событий

procedure TTextClass.SetData(const Value: string);  
begin  
  // Если определен метод обработки события, тогда вызываем его  
  if Assigned(FBeforeSetText) then FBeforeSetText(Self, Value);  
  FData := Value;  
  // Если определен метод обработки события, тогда вызываем его  
  if Assigned(FAfterSetText) then FAfterSetText(Self, Value);    
end;

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

unit Main;    
interface  
uses  
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,  
  Dialogs, uTest;  
type  
  TfrmMain = class(TForm)  
    procedure FormCreate(Sender: TObject);  
    procedure FormDestroy(Sender: TObject);  
    procedure FormClick(Sender: TObject);  
  private  
    FText: TTextClass;  
  public  
     // Объявляем переменную созданного нами класса  
    property Text: TTextClass read FText write FText;      
    // Процедура реагирование на событие – ДоИзменение текста.   
    //Входные параметры должны соответствовать типу события(в нашем случае TTextNotify)  
    procedure DoBeforeSetText(Sender: TObject; Text: string);  
    // Процедура реагирование на событие – ПослеИзменение текста.  
    procedure DoAfterSetText(Sender: TObject; Text: string);       
  end;  
var  
  frmMain: TfrmMain;  
implementation  

{$R *.dfm}
  
procedure TfrmMain.FormCreate(Sender: TObject);  
begin  
  Text := TTextClass.Create;  
  Text.Data := 'Test1';    
  Text.BeforeSetText := DoBeforeSetText;  
  Text.AfterSetText := DoAfterSetText;  
end;

procedure TfrmMain.FormDestroy(Sender: TObject);  
begin  
  Text.Free;  
end;

procedure TfrmMain.DoAfterSetText(Sender: TObject; Text: string);  
begin  
  ShowMessage(Text);  
end;

procedure TfrmMain.DoBeforeSetText(Sender: TObject; Text: string);  
begin  
  ShowMessage(Text);  
end;

procedure TfrmMain.FormClick(Sender: TObject);  
begin  
  Text.Data := 'Test2';  
end;  
end.

Если все сделали правильно, то после клика по форме, сначала покажется сообщение с «Тест1», а потом «Тест2». Таким же образом можно объявлять собственные события, и для визуальных компонент, и прочих классов которые можно написать в Delphi.

Проверка валидности PE-файла

Комментариев нет:
Автор: Goppit / ARTeam [www.accessroot.com]
Перевод: Rob [www.delphiday.blogspot.com]

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

Обычно, для проверки того, что файл является правильным PE, нам необходимо проверить два условия. Необходимо, чтобы текст в начале DOS заголовка имел значение “MZ” и в конце самого DOS заголовка имелся указатель на заголовок PE, который в свою очередь начинается с “PE”, который завершается двумя нулевыми байтами. Эти сигнатуры объявлены в инклуднике windows.inc и имеют следующий вид:

IMAGE_DOS_SIGNATURE   equ   5A4Dh        ("MZ")
IMAGE_NT_SIGNATURE    equ   00004550h    ("PE" 00 00)

Взлом Delphi компонент на примере TAdvMemo от TMS Software

9 комментариев:
Существует огромное множество нужных и не очень компонентов. Красивых и довольно аскетичных, бесплатных и платных. Платные компоненты как правило, функциональны, востребованы в большинстве случаев, красиво выглядят, как с точки зрения кода, так и интерфейса. Оно и правильно, ведь они созданы для того, чтобы быть проданными. Одним из таких компонентов является TAdvMemo, от конторы TMS Software. Если вы не сталкивались с ним, то советую вам прочитать мой мини-обзор на эту тему. Компонент действительно заслуживает внимания.

Простой шаблон кейгена

Комментариев нет:
Автор: Goppit / ARTeam [www.accessroot.com]
Перевод: Rob [www.delphiday.blogspot.com]
Номер тьюториала: #6, Simple Keygen Template.

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

Динамическая загрузка строк из STRINGTABLE

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

1. Для таких строк память не будет выделяться до того момента, когда этого не потребует ваше приложение или этого не захотите вы.

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

Приведу пример программы, которая в зависимости от выбора пользователя, устанавливает тот, или иной язык интерфейса. Нарисуйте форму следующего вида:


Имена управляющих элементов дефолтные, для удобства. Определим новые методы в классе TForm1:

• Procedure SetLanguage (LangFile:String);
• Procedure SelectLanguage (Language:TLang);

Так же определим новый тип: TLang = (lgRUS,lgENG); И запрограммируем наши новые методы:

procedure TForm1.SetLanguage(LangFile: String);
const
  NULL = 0;
var
  DLLHwnd:THandle;
  chBuff:array [0..255] of Char;
  i:integer;
begin
  DLLHwnd := LoadLibrary(PChar(ExtractFilePath(Application.ExeName)+'\lang\'+LangFile));
  if DLLHwnd <= NULL then
    Application.MessageBox('Не удаётся загрузить файл языка!','Ошибка!',MB_ICONERROR)
  else
   begin
    try
      for i := 1 to 5 do
        begin
          LoadString(DLLHwnd,i,@chBuff,sizeof(chBuff));
          case i of
            1: Button1.Caption := StrPas(chBuff);
            2: Button2.Caption := StrPas(chBuff);
            3: Form1.Caption   := StrPas(chBuff);
            4: Button3.Caption := StrPas(chBuff);
            5: Button4.Caption := StrPas(chBuff);
          end;
        end;
    except
     Application.MessageBox('Вы уж простите но чёт случилось! =)','Ошибка!',MB_ICONERROR)
    end;
   end;
end;

procedure TForm1.SelectLanguage(Language: TLang);
begin
  case Language of
    lgRUS: Self.SetLanguage('Russian.dll');
    lgENG: Self.SetLanguage('English.dll');
  end;
end;
На событие OnChange управляющего элемента ComboBox1 напишите следующий код:
procedure TForm1.ComboBox1Change(Sender: TObject);
begin
  if ComboBox1.Text = 'Русский' then Self.SelectLanguage(lgRUS)
    else if ComboBox1.Text = 'English' then Self.SelectLanguage(lgENG);
end;
В ComboBox1 у нас два элемента: Русский и English. При выборе одного из двух значений, происходит обращение к методу SelectLanguage с определённым параметром, который в свою очередь обращается к методу SetLanguage и передаёт в него строку. Эта строка является именем той библиотеки, которая содержит строки на выбранном языке.

В общем, метод SetLanguage и загружает строки для определённого языка, а так же устанавливает заголовки всех элементов управления. Код достаточно прост для понимания, так что комментариев приводить больше нет смысла. Единственное замечание: если вы впервые используете функцию LoadString, уточните её описание в MSDN. Скажу только, что 2,3 и 4 – это номер ресурса-строки в библиотеке, указатель на буфер, в который будет считана строка, размер буфера.

Теперь давайте посмотрим, как создать DLL со строковыми ресурсами:
Прежде всего в директории с проектом необходимо создать файл с расширением *.rc следующего содержания:
STRINGTABLE
{
1, "&Удалить"
2, "&Добавить"
3, "Простое приложение для демонстрации таблиц строк"
4, "Вы&ход"
5, "О программе..."
}
Как вы видите, это сами строки и их номера. Теперь следует откомпилировать этот файл компилятором ресурсов BRCC32.EXE который естественно входит в поставку Delphi. После компиляции, новоиспечённый файл *.res можно как обычно прилинковывать к проекту DLL. Следует сказать, что сама библиотека может и не содержать ни одной экспортируемой функции, в этом случаи DLL будет содержать только ресурсы.

Компонента TAdvMemo от компании TMS

Комментариев нет:

Вообще я не большой поклонник сторонних компонентов, а особенно платных, но, взглянув на возможности этого, я подумал, что стоит определённо его попробовать. Что же он из себя представляет? Да в нём есть всё, что может понадобиться при разработке редакторов кода, чатов, блокнотов и т.д. В общем, всего, где должна быть гибкая и красивая Memo.

Давайте я расскажу побольше о возможностях этого компонента, а вы тем временем поставьте на закачку архив компонента, который находится по этому адресу. Во первых – это полностью настраиваемая и гибкая система подсветки программного кода. Всё это дело реализовано в виде дополнительных компонент, которые и отвечают за подсветку. Так, например дополнительная компонента AdvPascalMemoStyler отвечает за распознавание и окраску паскалевского кода, а AdvPHPMemoStyler – за PHP.

Так же, очень понравилась возможность компоненты под названием AutoCorrect, которая особенно пригодится разработчикам чатов или IDE. Работает она достаточно тривиально, простой заменой одного на другое. Ну, например мы пишем prcedure а она нам заменяет его на procedure. В чатах, например таким образом можно вырезать мат и оскорбления. На самом деле можно придумать многие пути применения этой возможности. Единственное, это нельзя заменить многострочный текст на многострочный, так как строки заменяемые и заменяющие находятся в двух разных массивах TStringList, где один элемент – одна строка.

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

Описывать все возможности данной компоненты можно достаточно долго. Стоит ещё сказать, что можно присмотреться к другим вкусным вещам, например, полю UndoLimit, которое позволяет задать максимальное число отмен изменений (клавишами Ctrl+Z). Возможности AutoCompletion, гибко кстати настраиваемой. Для тех, кто не понял, AutoCompletion – это функция автозавершения строки. Например, вы пишите Show, и в окошке выводятся варианты сниппетов кода, которые начинаются с Show. Очень полезно.

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

Есть в этом чуде одна большая ложка дёгтя. Компонент платный. При бесплатном использовании (Demo режим), он работает нормально, но только пока работает в контексте IDE (как и многие другие платные компоненты). Да и копирайт в самой Memo трудно не заметить. Но нужно отдать должное, при закрытии IDE, компонента всё-таки остаётся работоспособной, в отличие от многих других платных разработок. Правда выдаёт при запуске приложения окошко, что мол триал версия наших компонентов используется в этой разработке.


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

Скелет программы на ассемблере

Комментариев нет:
Автор: Goppit / ARTeam [www.accessroot.com]
Перевод: Rob [www.delphiday.blogspot.com]
Номер тьюториала: #1, Basic Assembly Program Skeleton.

Использование WinAsm

На следующем скриншоте запечатлёна часть интерфейса среды WinASM. Исходный код, который вы набираете, появляется в левой части среды – в панели исходного кода. Панель обзора отображает файлы, которые в свою очередь являются частью текущего проекта (файлы исходного кода - *.asm, инклудники - *.inc, файлы ресурсов, и т.д). Кнопка “Go All” (на скриншоте указана курсором мыши) соберёт, слинкует и запустит на выполнение результирующий exe файл. Комманды ассемблера и линковщика с результатами компиляции и компоновки вы можете лицезреть в нижнем окне – в панели вывода.


Delphi. Как написать лоадер

Комментариев нет:
Автор: Sunshine [www.sunshine2k.de]
Перевод: Rob [www.delphiday.blogspot.com]

От переводчика:
Данный тьюториал покажет основы написания лоудеров. Написан начинающим немецким реверсером и программистом. Изложено доступно, приведён исходный код лоудера. Перевод в некоторых местах вольный. Автор статьи постарался доступным языком, для таких же новичков как и он, обьяснить то, чего сам не мог понять из за отсутствия материала, то есть той базы, которой некоторое время не хватало ему. Статья будет очень интересна новичкам в реверсинге и программировании.


В данном тьюториале, я постараюсь объяснить, как написать лоудер для программы, если вы не хотите или не можете патчить программу стандартным способом, если например она запакована или проверяет свою контрольную сумму перед выполнением, или что либо ещё – причин для этого может быть много.
В своё время, я долго пытался найти статью, которая бы пролила свет на эту тему и тот туториал, что я нашел оказался на ассемблере, который я ещё мало понимал (пока!). Вот почему я решил написать статью, по программированию лоудера на Delphi.
Я написал простой крякми, который будет взломан с помощью нашего с вами лоудера. Но учтите, что реальную запакованную программу пропатчить будет сложнее, нежели наш крякми. Давайте начнём!

Исключите всё элементы из Auto Create Forms, кроме главной формы

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

В файле проекта убирайте всё, что не относится к созданию главной формы. Например, вот так:
Application.Initialize;
Application.CreateForm(TForm1, Form1);
// Application.CreateForm(TForm2, Form2);
// Application.CreateForm(TForm3, Form3);
// Application.CreateForm(TForm4, Form4);
// Application.CreateForm(TForm5, Form5);
Application.Run;

А остальные формы создавайте только по мере необходимости. Например, так:
procedure TForm1.ShowAboutBox();
begin
 Application.CreateForm(TForm2, Form2);
 Form2.Show;
end;

К тому же, редко используемые формы, такие как форма “О программе…” желательно вообще освобождать при закрытии методом Free и обнулять значением nil. Для чего – ясно. Стоит заметить, что в таких случаях, как вы наверное уже догадались, новая форма будет создаваться вновь и вновь, при каждом вызове метода ShowAboutBox. Я обычно в таких случаях просто затеняю ту кнопку или другой контрол, который вызывает метод (что конечно не совсем по правилам прилежного программирования), однако вы можете использовать примерно следующюю конструкцию:
if not Assigned(Form2) then 
 Application.CreateForm(TForm2, Form2);
Form2.Show;

Итак, обрисовывается полная картина использования таких форм. На примере нашей формы вывода информации о программе, привожу следующий код:
procedure TMainForm.AboutButtonClick(Sender: TObject);
begin
 Self.ShowAboutBox;
end;

procedure TMainForm.ShowAboutBox;
begin
 if not Assigned(AboutBox) then Application.CreateForm(TAboutBox, AboutBox);
 AboutBox.Show;
end;

procedure TAboutBox.FormClose(Sender: TObject; var Action: TCloseAction);
begin
 Self.Free;
 AboutBox:=nil;
end;


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

Доступ к -4 смещению дельфовой строки

Комментариев нет:
Часто слышишь о том, что по смещению -4 от начала строки находится двойное слово с её длиной и количеством ссылок по смещению -8. Но обычная конструкция вида string[-4]{[-8]} компилироваться категорически отказывается, тыкая мессагой про какие то там границы диапозонов… Но как так? Если в делфи строке там лежит длина, то почему её нельзя взять или изменить? На самом деле можно, и ещё как… Хотя компилятор и отказывается нас туда пускать, мы пойдём обходным путём, прибегнув к ассемблерным вставкам:
function asm_strlen(s:string):integer;
asm
  mov eax,dword ptr[eax-4]
end;

Алгоритм предельно прост. Так как по умолчанию параметры передаются в регистрах, то указатель на нашу строку попадает в регистр EAX. И теперь мы копируем в EAX двойное слово, которое располагается по адресу EAX-4. Кстати изменить длину строки так же легко:
procedure asm_setlen(s:string;Size:Dword);
asm
  mov dword ptr[eax-4],edx
end;

Всё одно и тоже, только теперь мы из регистра записываем в пямять. Такими же методами, мы можем получить или устанавливать количество ссылок на строку, используя -8 смещение. Конечно, мы можем описать вышеприведённые действия и не прибегая к ассемблеру, но конструкции вида:
procedure(...)
  Dword(Pointer(Dword(Pointer(Str))-4)^) := size;
end;
...

Нравятся не всем.

Кстати, таким нехитрым трюком можно брать значение по -8 адресу (кол-во указателей на строку). И даже менять это значение ;)