Long writelong (long handle,long dword,long mostfirst);

Функция записывает четыре байта в файл. До начала операции файл должен быть открыт функцией fopen с правами на запись.

Примечательной особенностью данной функции является возможность трансляции знакового бита во время чтения.

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

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

Операнд	Пояснения
Handle	Дескриптор открытого с правами на запись файла
Mostfirst	==0	Знаковый байт самый старший в слове
	==1	Знаковый байт самый младший в слове
Return	Завершение		Пояснения
	Норма		0
	Ошибка		!=0

Char readstr (long handle);

Функция читает стоку из файла (с текущей позиции до символа EOL). До начала операции файл должен быть открыт функцией fopen с правами на чтение.

Не зависимо от заданного типа при открытии файла (текстовой или двоичный) readstr всегда правильно распознает конец стоки представленный как 0xD 0xA, так и 0xA. Однако если файл открыт как текстовой, то функция будет преобразовывать все символы 0xA в 0xD 0xA. Что можно наблюдать на следующем примере:

auto a;

a=fopen("readme.txt","rb");

Message(readstr(a));

This patch allows you to permanently access the bonus track and bonus car♪

auto a;

a=fopen("readme.txt","rt");

Message(readstr(a));

This patch allows you to permanently access the bonus track and bonus car

Операнд	Пояснения
Handle	Дескриптор открытого с правами на чтение файла
Return	Завершение	Пояснения
	Норма	Считанная строка
	Ошибка	“”

Long writestr (long handle,char str);

Функция записывает стоку в файл. До начала операции файл должен быть открыт функцией fopen с правами на запись.

Если файл открыт как текстовой, то функция будет преобразовывать все символы 0xA в 0xD 0xA.

Операнд	Пояснения
Handle	Дескриптор открытого с правами на чтение файла
str	Записываемая строка
Return	Завершение	Пояснения
	Норма	0
	Ошибка	!=0

Виртуальные массивы организация массивов

IDA поддерживает два типа массивов, и это иногда порождает небольшую путаницу.

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

seg000:0006 db 0A0h,0ACh,0AEh,0A3h,0AEh, 20h,0ADh,0A0h

seg000:0006 db 0A0h, 20h,0ADh,0A0h,0A4h,0AEh, 20h,0AEh

И массивы как выделенные области памяти под нужды скрптовых программ. Вот их-то мы сейчас и рассмотрим. Они концептуально очень сильно отличаются от привычных для нас массивов языков Си и Паскаль.

Скорее это объект, который в Microsoft непременно бы назвали CArray, предоставляющий соответствующие API, но скрывающий реализацию всех своих методов.

Уникальность массивов IDA в том, что они поддерживают смешанный тип данных. В одном и том же массиве можно хранить как числа, так и стоки. Правда обработку типов (или в принятой терминологии тегов) IDA возлагает на наши плечи и нам придется явно указывать стоковое ли это значение или нет.

Очень приятно, что IDA поддерживает разряженные массивы, то есть индексированные произвольным образом. С первого взгляда они могут напоминать списки, но на самом деле это не так. Обыкновенные разряженные массивы.

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

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

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

Массивы сохраняются в базе IDA (а точнее в Btree) до момента их принудительного удаления. Это же, разумеется, относиться и к сегментам, но массивы в отличие от последних не загромождают дизассемблируемый текст.

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

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

Для этого нам потребуется познакомиться с базовыми операциями над массивами. Начнем с создания.

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

long CreateArray(char name);

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

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

long GetArrayId(char name);

Если указанного массива не существует, то она возвратит BADADDR, в противном случае идентификатор. С помощью идентификатора массив в любой момент можно переименовать функцией:

success RenameArray(long id,char newname);

С другой стороны, если Вам не нравятся конструкции типа:

auto ID;

ID=GetArrayId("MyArray");

RenameArray(ID,"MyRenamedArray");

то можно непосредственно получить идентификатор "на лету" типа:

RenameArray(GetArrayId("MyArray"),"MyRenamedArray");

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

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

Создавая массивы, необходимо помнить, что они располагаются не в оперативной памяти, исчезая после перезапуска IDA, а в базе. И перезапуск не разрушает их.

Увлекшись созданием массивов, особенно на этапе знакомства и экспериментирования с ними, можно не только "скушать" порядочно ресурсов, но и заблокировать многие имена, так что потом при попытке создания массива с идентичным именем возникнет непонятно с чем связанная на первый взгляд ошибка.

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

void DeleteArray(long id);

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

При запуске выполним следующие действия (для этого достаточно включить эту строку в файл ida.idc):

CreateArray("SysListTempArray");

Теперь определим функцию:

static СreateTempArray(Name)

{

auto a,temp;

temp=GetLastIndex('S',GetArrayId("SysListTempArray"));

a=CreateArray(Name);

if (a>0) SetArrayString(GetArrayId("SysListTempArray",++temp,Name);

return a;

}

При выходе из IDA уже нетрудно будет удалить все временные массивы из базы автоматически.

Однако, в этом на первый взгляд логичном поступке, есть одна ошибка. Давайте подумаем, а что случиться, если сеанс работы будет аварийно завершен? Правильно, наш скрипт не получит управления и временные массивы не будут удалены!

Поэтому необходимо очищать их при входе (запуске) IDA. При этом массив "SysListTempArray" будет необходимо создавать только один раз для каждой новой базы.

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

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

Массивы IDA имеют и другую уникальность. Один и тот же элемент (а точнее индекс) может одновременно содержать строковое и числовое значения, причем оба не перекрывают друг друга. Т.е. вместо одного массива мы как бы получаем целых два!

Для задания значений элементов используется пара функций:

success SetArrayLong (long id,long idx,long value);

success SetArrayString(long id,long idx,char str);

Причем обе функции могут принимать как символьный, так и числовой тип значения.

SetArrayString(id,idx,0x21) занесет в ячейку знак '!' и соответственно SetArrayLong (id,idx,'!*') - 0x2A21.

Это бывает очень удобно для преобразования типов данных, которое IDA выполняет автоматически.

Примечательно, что не нужно предварительно каким-либо образом задавать размер массива. Просто указываете требуемый индекс вот и все.

Всего доступно 0x100000000 индексов (32 бита), что позволяет расширять массивы, не только "вперед", но и "назад".

IDA прекрасно справляется с отрицательными указателями. Не стоит, однако забывать, что отрицательные указатели на самом деле трактуются как беззнаковые и расширение массива "назад" происходит по кольцу.

Чтение элементов массива выполняется несколько неожиданным способом. Вместо двух функций GetArrayLong и GetArrayString используется одна:

char or long GetArrayElement(long tag,long id,long idx);

Уточнение типа, требуемого элемента выполняется через тег. Если он равен 'A', то функция возвратит числовое значение, и строковое в противном случае.

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

Можно так же использовать и определения AR_LONG и AR_STR, однако, на мой взгляд, их несколько утомительнее писать. С другой стороны, использовать непосредственные значения более рискованно в плане возможной несовместимости с последующими версиями.

idx - это индекс элемента массива. Традиционно в большинстве языков программирования (например, Си) нет никаких средств навигации по индексам и даже невозможно узнать, сколько элементов содержит массив и какие из них инициализированные, а какие нет.

Всех этих проблем нет в IDA.. Индекс первого элемента поможет узнать функция:

long GetFirstIndex(long tag,long id);

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

Соответственно, индекс последнего элемента поможет найти функция:

long GetLastIndex(long tag,long id);

Следующий или предыдущий индекс в цепочке можно найти с помощью функций:

long GetNextIndex(long tag,long id,long idx);

и

long GetPrevIndex(long tag,long id,long idx);

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

Ну и, наконец, удалить любой элемент массива можно с помощью функции:

success DelArrayElement(long tag,long id,long idx);

Теперь можно попробовать реализовать наш проект "Записная книжка". Начнем с создания массива. С первого взгляда стоило бы реализовать такую конструкцию:

if (GetArrayId("Notepad")==-1) CreateArray("Notepad");

однако, можно ограничиться вызовом CreateArray("Notepad"), т.к. если массив уже существует, то функция вернет ошибку вот и все. И если обращаться к массиву по имени, то совершенно необязательно сохранять его ID.

Реализуем функцию "NotepadAdd" для внесения новых записей:

static NotepadAdd(s0)

{

SetArrayString(GetArrayId("Notepad"),

GetLastIndex(GetArrayId("Notepad"))+1,

s0);

}

И естественно просмотр онных:

static NotepadPrint()

{

auto a;

a=0;

Message("Блокнот: \n");

while((a=GetNextIndex('S',GetArrayId("Notepad"),a))>0)

Message("%s \n",GetArrayElement('S',GetArrayId("Notepad"),a));

}

Чуть позже мы добавим к "Блокноту" соответствующий интерфейс, а пока будем пользоваться его функциями с консоли. Нажмем <Shift-F2> и введем

NotepadAdd("Это только тест");

и нажмем <Ctrl-Enter>. Затем вызовем консоль еще раз и введем еще одну строку

NotepadAdd("Пусик хочет кушать");

Попробуем посмотреть содержимое блокнота командой

NotepadPrint();

Блокнот:

Это только тест

Пусик хочет кушать

А теперь реализуем наш "универсальный расшифровщик" на массивах и сравним с предбудущими результатами.

auto a,temp;

CreateArray("MyArray");

for (a=SegStart(0x10000);a<SegEnd(0x10000);a++)

SetArrayLong(GetArrayId("MyArray"),

Byte(a),GetArrayElement('A',GetArrayId("MyArray"),

Byte(a))+1);

a=GetFirstIndex('A',GetArrayId("MyArray"));

temp=0;

while(1)

{

if (GetArrayElement('A',GetArrayId("MyArray"),a)>GetArrayElement('A',GetArrayId("MyArray"),a)) temp=a;

a=GetNextIndex('A',GetArrayId("MyArray"),a);

}

// процедура дешифровки

//

DeleteArray(GetArrayId("MyArray"));

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

Поскольку созданный массив заполнен едва ли не на треть, то переход по элементам списка функцией GetNextIndex() заметно быстрее перебора всего массива в цикле, как это было в предбудущем примере.

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

Большой неожиданностью явилась поддержка IDA Perl-подобных ассоциативных массивов. Кардинальное отличие их обычных заключается в возможности индексирования элементов строковыми значениями.

Например:

a["Москва"] = "Москва-Столица";

a["Кремль"] = "Старинное здание в Москве";

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

При этом внутренне представление индексов таких массивов очень компактно и быстродествющие.

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

Впрочем, с какой-то стороны это и оправдано. Ассоциативные массивы реализованы "поверх" существующих, и отличаются только тем, что используют строковые, а не числовые индексы.

К ним применимы функции CreateArray, GetArrayID, RenameArray и остальные. Различие лишь в том, что все функции ассоциативных массивов не имеют тегов. Это означает, что один и тот же индекс не может одновременно ссылаться на строковое и числовое значение. Поэтому следующий пример вернет '0x1234', т.к. последнее присвоение затирает предыдущее.

SetHashString(GetArrayId("MyArray"),"1st","Это строка");

SetHashLong (GetArrayId("MyArray"),"1st",0x1234);

Message("%x \n",GetHashLong(GetArrayId("MyArray"),"1st"));

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

long GetHashLong(long id,char idx);

char GetHashString(long id,char idx);

Не смотря на то, что эти функции работают непосредственно с массивом созданным CreateArray они не могу видеть или модифицировать элементы, заданные SetArrayLong\SetArrayString, поэтому можно безбоязненно использовать один массив для разных нужд.

Удалить любой элемент ассоциативного массива можно с помощью функции:

success DelHashElement(long id,char idx);

При удалении элементов IDA неявно инициализирует случайным значением, в отличие от DelArrayElement, которая в этом случае как и следует ожидать обнуляет ячейку.

Однако, это не вызовет проблемы, если для доступа к элементам использовать функции:

char GetFirstHashKey(long id);

char GetNextHashKey(long id,char idx);

char GetLastHashKey(long id);

char GetPrevHashKey(long id,char idx);

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

МЕТОДЫ

Функция	Назначение
long CreateArray(char name)	Создает новый массив
long GetArrayId(char name)	Возвращает идентификатор массива по его имени
success RenameArray(long id,char newname)	Переименовывает массив
void DeleteArray(long id)	Удаляет массив
success SetArrayLong(long id,long idx,long value)	Присваивает значение индексу массива типа «длинное целое»
success SetArrayString(long id,long idx,char str)	Присваивает значение индексу массива типа «строка»
char or long GetArrayElement(long tag,long id,long idx	Возвращает значения обоих типов элементов
success DelArrayElement(long tag,long id,long idx)	Удаляет один элемент массива
long GetFirstIndex(long tag,long id);	Возвращает индекс первого элемента
long GetLastIndex(long tag,long id);	Возвращает индекс последнего элемента
long GetNextIndex(long tag,long id,long idx)	Возвращает следующий индекс элемента массива
long GetPrevIndex(long tag,long id,long idx)	Возвращает предыдущий индекс элемента массива
success SetHashLong(long id,char idx,long value	Присваивает значение элементу массива типа «длинное целое»
success SetHashString(long id,char idx,char value);	Присваивает значение элементу массива типа «строка»
long GetHashLong(long id,char idx)	Возвращает значение элемента типа «длинное целое»
char GetHashString(long id,char idx)	Возвращает значение элемента типа «строка»
success DelHashElement(long id,char idx)	Удаляет элемент ассоциативного массива
char GetFirstHashKey(long id)	Возвращает индекс первого элемента массива
char GetLastHashKey(long id)	Возвращает индекс последнего элемента массива
char GetNextHashKey(long id,char idx)	Возвращает индекс следующего элемента массива
char GetPrevHashKey(long id,char idx);	Возвращает индекс предыдущего элемента массива