Ас Push’кин
(из классификатора «Эсхатологические мутанты»)
Ас Push’кин
(из классификатора «Эсхатологические мутанты»)
Совсем краткое пояснение. Как театр начинается с вешалки, так программа на ассемблере MASM начинается с указания набора инструкций:
.386
Это ассемблеpная диpектива, говоpящая ассемблеpу использовать набоp опеpаций для пpоцессоpа 80386. Вы также можете использовать .486, .586, но самый безопасный выбоp — это указывать .386. Также есть два пpактически идентичных выбоpа для каждого ваpианта CPU. .386/.386p, .486/.486p. Эти «p»-веpсии необходимы только когда ваша пpогpамма использует пpивилигиpованные инстpукции, то есть инстpукции, заpезеpвиpованные пpоцессоpом/опеpационной системой в защищенном pежиме. Они могут быть использованны только в защищенном коде, напpимеp, дpайвеpами. Как пpавило, ваши пpогpаммы будут pаботать в непpивилигиpованном pежиме, так что лучше использовать не-«p» веpсии. (Из мануала Iczelion’а)
.model flat
.model
— модель памяти, используемая вашей программой. Для DOS, например, были модели tiny
, small
, compact
, flat
, lagre
и т.д. — они выбирались в зависимости от типа программы. По ограничениям DOS сегмент кода не мог занимать пространство, больше размера одного сегмента в памяти. Чтоб это обойти, как раз и использовалась сегментация. Tiny
и flat
могли быть использованы для оригинальных DOS-программ, с расширением .com
, которые могли занимать чуть меньше одного сегмента (64 Кб), на код и данные, и представляли собой просто кусок кода вместе с данными, можно сказать RAW-формат исполняемого файла — просто откомпилированный байткод, даже без всякого заголовка. Для EXE формата, код и данные могли занимать несколько сегментов.
В Win32 сегментация памяти не нужна, во-первых, размер адреса 32-битный, что больше, чем в DOS, во-вторых, менеджментом памяти занимается ОС, потому программа видит все нужные ей внешние библиотеки и функции из них, как если бы они были загружены в адресное пространство программы. Таким образом, программа под Win32 изнутри представляет такой себе очень большой .COM-файл, потому используется только одна модель памяти — flat
.
.model flat, stdcall
У директивы .model
есть несколько важных параметров, самый главный из них, указание на передачу параметров функций (обычно внешних, из DLL, но никто не мешает для своих функций использовать). Его и указываем через запятую (stdcall
).
Есть три способа передачи параметров:
— C
(си) способ: вызывающая, т.е. наша программа, должна положить в стек нужные параметры, причем, в обратном порядке. Например, если функция описывается так:
SomeFunction (Argument1, Argument2, Argument3)
То на ассемблере она вызывается так:
push Argument3
push Argument2
push Argument1
call SomeFunction
А далее, вызывающая программа должна почистить стэк (по-научному это называется «уравнять»), push
уменьшает значение регистра стека на размер операнда (2 или 4 байта), пусть будет 4, тогда получается, что надо увеличить значение стека на 3x4=12
байт.
add SP, 12
C-поpядок полезен, когда вы не знаете, как много паpаметpов будут пеpеданны функции
— PASCAL
— это C
соглашение наоборот, параметры передаются в прямой последовательности, т.е. первый параметр кладется в стек первым, а со стеком должна разбираться сама вызываемая функция.
— STDCALL
— это гибрид C
и PASCAL
соглашения, параметры передаются в обратном порядке, но со стеком разбирается вызываемая функция.
Win32 использует практически исключительно STDCALL
соглашение для своего API, исключая функцию wsprintf()
, потому что она не знает, сколько ей будет передано параметров. При ее вызове следует использовать C
-соглашение.
Если вы используете include-файл windows.inc
в MASM, и при компиляции происходит ошибка windows.inc(78) : error A2119: language type must be specified
, значит, забыли указать параметр stdcall
в директиве .model
Хозяину леса, естественно, сигаретку оставили. Без фильтра не было.
Некоторые дурни думают, что мы на полевки на «Оке» ездим. Хотя вообще, я хочу мафынку для выездов, как в «Обители зла», можно без лого «Амбреллы».
Да, купил новый фот. Засру вам ленту своим непрофессионализмом.
npp_save
cd "$(CURRENT_DIRECTORY)"
G:\masm32\bin\ml.exe /c /coff /IG:\masm32\include\ $(FILE_NAME)
if $(EXITCODE) !=0 goto exit
G:\masm32\bin\link.exe $(NAME_PART).obj /SUBSYSTEM:CONSOLE /LIBPATH:G:\masm32\lib\
:exit
Не всегда корректно работает, как сделать, пока не разобрался.
npp_save
cd "$(CURRENT_DIRECTORY)"
G:\masm32\bin\ml.exe /c /coff /IG:\masm32\include\ $(FILE_NAME)
if $(EXITCODE) !=0 goto exit
G:\masm32\bin\link.exe $(NAME_PART).obj /SUBSYSTEM:CONSOLE /LIBPATH:G:\masm32\lib\
if $(EXITCODE) !=0 goto exit
$(NAME_PART).exe
:exit
npp_save
cd "$(CURRENT_DIRECTORY)"
G:\masm32\bin\ml.exe /c /coff /IG:\masm32\include\ $(FILE_NAME)
if $(EXITCODE) !=0 goto exit
G:\masm32\bin\link.exe $(NAME_PART).obj /SUBSYSTEM:WINDOWS /LIBPATH:G:\masm32\lib\
:exit
npp_save
cd "$(CURRENT_DIRECTORY)"
G:\masm32\bin\ml.exe /c /coff /IG:\masm32\include\ $(FILE_NAME)
if $(EXITCODE) !=0 goto exit
G:\masm32\bin\link.exe $(NAME_PART).obj /SUBSYSTEM:WINDOWS /LIBPATH:G:\masm32\lib\
if $(EXITCODE) !=0 goto exit
$(NAME_PART).exe
:exit
masm-compile-console.txt
masm-compile-console-and-run.txt
masm-compile-windows.txt
masm-compile-windows-and-run.txt
masm-compile-console.txt
masm-compile-console-and-run.txt
masm-compile-windows.txt
masm-compile-windows-and-run.txt
Да, пока показывал школьникам ассемблер, записал пару макросов, которые создают шаблон программы, а то лень писать .386, model flat и т.д., но, поскольку, делал это в основном на своем компьютере, встал вопрос — а нельзя ли макросы перенести на другой комп, ну и забэкапить для верности. Оказывается, можно.
Бэкап делается просто. Макросы хранятся в файле C:\Users\<username>\AppData\Roaming\Notepad++\shortcuts.xml
для Windows 7. В остальных системах ищите shortcuts.xml
, а где он находится у вас — не ведаю.
Если надо перенести макрос с одного компьютера на другой, открываем файл shortcuts.xml
в любом текстовом редакторе.
Макросы находятся между XML-тегами <Macros>
</Macros>
, а конкретный макрос между тегами <Macro ...>
</Macro>
где, в первом, открывающем теге, указаны параметры макроса: имя (name=
), и комбинация клавиш для вызова (Ctrl="no" Alt="no" Shift="no" Key="0"
).
Если необходимо перенести макрос с одного компьютера на другой, просто скопируйте строки, начинающиеся с <Macro name="ваш_макрос">
до </Macro>
включительно, и вставьте макрос на целевом компьютере в файл shortcuts.xml
между тегами <Macros> </Macros>
Макрос для создания «болванки» исходника для TASM32 на PasteBin
Макрос для создания «болванки» исходника для TASM32 на GitHub
Макрос для создания «болванки» исходника для MASM32 на PasteBin
Макрос для создания «болванки» исходника для MASM32 на GitHub
Шумел камыш, деревья гнулись
А Вова с Сашей ебанулись.
На рассвете цивилизации ПК и примерно до того времени, когда появились инструменты программирования Microsoft Win32, почти все компиляторы для ПК создавали объектные файлы с использованием стандарта Intel Object Module Format (OMF). Позже Intel представила процессоры 386 и 32-разрядный защищенный режим, после чего они также расширили спецификацию OMF для 32-разрядных систем, что привело к появлению «OMF-386», который стал стандартом для большинства сред защищенного режима ПК. Примерно в это же время исходная группа разработчиков Windows NT также разрабатывала код не только для процессоров Intel, но и для поддержки процессоров других производителей. Команда Microsoft NT выбрала более переносимый формат объектных модулей, известный как Common Object File Format (COFF), производный от официального формата объектного кода для UNIX System V. Объектные модули COFF позже стали стандартом де-факто для всех инструментов разработки Microsoft Win32 и получили преимущество в том, что он намного ближе по формату к переносимым исполняемым файлам (PE) — собственному исполняемому формату для Win32 (компоновщику формата COFF требуется гораздо меньше усилий для создания 32-разрядного EXE
или DLL
из файла COFF, чем из файла формата OMF).
Помимо объектных файлов форматов OMF и COFF (.obj
), существуют также файлы библиотек форматов OMF и COFF (.lib
). Библиотеки, к счастью, в основном представляют собой просто набор объектных файлов вместе с заголовочной информацией, которая позволяет компоновщику определить, какие объектные файлы из библиотеки использовать. Однако, чтобы усложнить ситуацию, и OMF, и COFF используют одни и те же расширения имен файлов, .obj
и .lib
, для ссылки на два разных типа форматов файлов объектов и библиотек (из-за этого вы не можете просто посмотреть на расширение имени файла чтобы узнать, является ли объектный модуль или файл библиотеки OMF или COFF).
Проблема со смешиванием объектных файлов и файлов библиотек от разных производителей компиляторов заключается в том, что одни поставщики поддерживают COFF, другие используют OMF, а некоторые могут работать и с тем, и с другим. Borland, например, по-прежнему использует объектные файлы и библиотеки OMF, тогда как 32-разрядные компиляторы Microsoft создают файлы формата COFF. Watcom C/C++ v11.0, по-видимому, предпочитает COFF при компиляции и компоновке приложений Windows, но создает объектные файлы OMF для использования с 32-разрядным DOS-расширителем защищенного режима DOS4GW. Microsoft MASM 6.13 по умолчанию создает файлы OMF, но параметр командной строки /coff
указывает компилятору, что он должен создавать объектные файлы COFF.
Когда приходится связывать файлы разных форматов, разные компоновщики делают разные вещи. Например, компоновщик Microsoft Visual C/C++ предназначен для объектных файлов и библиотек формата COFF, но при необходимости попытается преобразовать объектные файлы OMF в файлы COFF. В некоторых случаях это работает, но, к сожалению, Microsoft LINK не поддерживает все типы записей OMF, поэтому во многих ситуациях компоновщик может дать сбой при работе с объектными файлами формата OMF. Кроме того, хотя Microsoft LINK пытается поддерживать объектные файлы OMF, он отказывается обрабатывать любые библиотеки формата OMF. Другие компоновщики, такие как TLINK от Borland, предназначены для объектных файлов OMF и аналогичным образом отказываются работать с объектными или библиотечными файлами формата COFF. Некоторые поставщики расширителей DOS и встраиваемых систем, такие как Phar Lap, предоставляют свои собственные компоновщики, поддерживающие как OMF, так и COFF, что дает вам возможность выбора.
Проблема в том, что смешение OMF и COFF типов объектных файлов и файлов библиотек может привести к хаосу. Вдобавок появляются загадочные сообщения об ошибках от компоновщиков, которые только вносят еще большее непонимание. Если ваш компоновщик не поддерживает определенный формат, вам следует придерживаться рекомендуемого формата объекта и библиотеки для вашего компилятора/компоновщика/платформы и избегать смешивания файлов OMF и COFF.
Перевод: Leha Silent для tolik-punkoff.com
Оригинальный текст (англ., TXT) предоставил Jiang Yap из WeChat
Копия перевода в TXT
Небольшая шпаргалка по условным и безусловным переходам.
Безусловный переход: выполняется командой JMP <метка>
, может использоваться, как для перехода вперед, пропуская некоторые команды в коде, так и для возврата назад, для повторного выполнения инструкций:
1.
... какой-то код ... JMP label1 ... какой-то код ... label1: ... другой код выполняется после срабатывания инструкции JMP ...
2.
... какой-то код ... labelret: ... какой-то код ... JMP labelret
Условный переход: Выполняется, если выполнено какое-либо условие, переход осуществляется командой Jxx <метка>
, где xx
— мнемоника, указывающая на проверяемое условие.
Инструкция CMP
сравнивает два операнда, в основном вычитая один операнд из другого для сравнения, равны ли операнды или нет, не изменяя целевой или исходный операнд. Инструкция CMP
используется вместе с инструкцией условного перехода для принятия решения. CMP
изменяет регистр флагов, который потом проверяет соответствующая инструкция условного перехода, и осуществляет (не осуществляет) переход по соответствующему адресу (метке).
Синтаксис:
CMP целевой_операнд, исходный_операнд
CMP
сравнивает два числа. В качестве целевого операнда может использоваться значение в регистре или в памяти. Исходный операнд может быть константой (EQU
), непосредственно числом, значением в регистре или памяти. Так же, оба операнда не могут быть одновременно значениями в памяти.
Правильно | Неправильно | Ошибка (MASM) |
cmp eax, ecx | MYVALUE1 dd 2 MYVALUE2 dd 5 … cmp MYVALUE1, MYVALUE2 |
invalid instruction operands |
cmp eax, 0 | cmp 0, eax | immediate operand not allowed |
ERROR_FLAG EQU 16h … cmp eax, ERROR_FLAG |
ERROR_FLAG EQU 16h … cmp ERROR_FLAG, eax |
immediate operand not allowed |
MYVALUE dd ? … cmp eax, MYVALUE |
— | — |
MYVALUE dd ? … cmp MYVALUE, eax |
— | — |
MYVALUE dd ? … cmp MYVALUE, 0 |
MYVALUE dd ? … cmp 0, MYVALUE |
immediate operand not allowed |
MYVALUE dd ? ERROR_FLAG EQU 16h … cmp MYVALUE, ERROR_FLAG |
MYVALUE dd ? ERROR_FLAG EQU 16h … cmp ERROR_FLAG, MYVALUE |
immediate operand not allowed |
— | cmp 0, 1 | immediate operand not allowed |
— | CONST1 equ 1 CONST2 equ 2 … cmp CONST1, CONST2 |
immediate operand not allowed |
Также нужно быть внимательным при сравнении значения в памяти и регистре, если их размерность будет не совпадать, это приведет к ошибке компиляции. Например, при сравнении регистра EAX
, имеющего разрядность двойное слово (DWORD) с переменной, разрядность которой установлена, как байтовая (DB
):
...
MYVALUE db 1
...
cmp eax, MYVALUE
...
;Ошибка: invalid instruction operands
Инструкция | Описание | Проверяемые флаги |
JE/JZ | Если значения равны/Если значение 0 | ZF |
JNE/JNZ | Если значения не равны/Если значение не 0 | ZF |
JG/JNLE | Если больше/Если не меньше или равно | OF SF ZF |
JGE/JNL | Если больше или равно/Если не меньше | OF SF |
JL/JNGE | Если меньше/Если не больше или равно | OF SF |
JLE/JNG | Если меньше или равно/Если не больше | OF SF ZF |
Результаты арифметических операции для беззнаковых чисел или логических операций
Инструкция | Описание | Проверяемые флаги |
JE/JZ | Если значения равны/Если значение 0 | ZF |
JNE/JNZ | Если значения не равны/Если значение не 0 | ZF |
JA/JNBE | Если больше/Если не меньше или равно | CF ZF |
JAE/JNB | Если больше или равно/Если не меньше | CF |
JB/JNAE | Если меньше/Если не больше или равно | CF |
JBE/JNA | Если меньше или равно/Если не больше | AF CF |
Прочие инструкции для условных переходов
Эти инструкции имеют специальное применение и проверяют значения отдельных флагов во флаговом регистре.
Инструкция | Описание | Проверяемые флаги |
JXCZ | Если значение в регистре CX равно 0 | Нет |
JC | Если произошел перенос в результате арифметической операции | CF |
JNC | Перенос не произошел | CF |
JO | Произошло переполнение | OF |
JNO | Переполнение не произошло | OF |
JP/JPE | Число единичных бит четное | PF |
JNP/JPO | Число единичных бит нечетное | PF |
JS | Число со знаком (отрицательное) | SF |
JNS | Число без знака (положительное) | SF |
Ссылки
сбулочная
Любой ватан, сепар или оккупант боится попасть в такое заведение.
Хвастаюсь, да.
Очередная ссылочная.
Компиляторы:
— TASM/TASM32, компилятор для Windows x86 и DOS (Mega.NZ, ZIP, 4.6 Мб)
— MASM for DOS (Mega.NZ, ZIP, 4.6 Мб)
— MASM32, компилятор для Windows x86: Официальный сайт (копия на Mega.nz)
— IMPORT32.LIB
(7z, Mega.NZ) (копия на Google.Drive)
Туториалы Iczelion’а (RUS, перевод WASM.RU).
Довольно неплохое руководство по Win32 API для начинающих программистов на ассемблере. Начиная с простейших примеров и до довольно продвинутых программ, включая описание структур и функций Win32 API, структуры PE EXE-файла, простейших VxD-драйверов.
Перевод Aquila.
В комплекте исходники и бинарники примеров программ.
— На Old-DOS
— На mega.nz
Обещал сделать другу-школьнику, пусть тут описание валяется, не пропадать же.
.386
.MODEL FLAT
extrn ExitProcess:proc
extrn MessageBoxA:proc
.DATA
MSG_TITLE DB 'Hello, world!',0
MSG_MESSAGE DB 'I am running!',0
MB_INFORMATION DD 40h
.CODE
Start:
push MB_INFORMATION ;Message box style (Icon - Information)
push offset MSG_TITLE ;Message box title
push offset MSG_MESSAGE ;Message box text
push 0 ;hwndOwner
call MessageBoxA
push 0
call ExitProcess
end Start
Начало
1. Прописываем директиву совместимого процессора .386
(больше и не надо), и модель памяти FLAT
, стандартную для x86 PE исполняемых файлов.
2. Далее, экспортируем 2 функции WinAPI - ExitProcess
, которая позволит программе корректно завершиться, и MessageBoxA
, - функция вызовет стандартное диалоговое окно. Эти функции находятся в библиотеке IMPORT32.LIB
(есть в комплекте TASM), так что они станут доступны программе на этапе линковки, а директива extrn показывает компилятору, что функции внешние, т.е. компилятор не будет ругаться, что не нашел их в исходнике при компиляции.
Примечание: Кроме функции WinAPI MessageBoxA
, есть функция MessageBoxW
, параметры у этой функции аналогичные, но используется она, если выводимый текст в кодировке UTF-16.
3. В секции данных (.DATA
) определяем константы: MSG_TITLE
и MSG_MESSAGE
, содержащие, соответственно, строку заголовка и строку, содержащую текст в диалоговом окне. Строки должны оканчиваться символом с кодом 0
(,0
)
Примечание: Не строковым символом "0
", а нулевым байтом.
4. Также определяем четырехбайтовую (DD
) константу, которая будет управлять поведением окна. В данном случае MB_INFORMATION
, которой укажем значение 40h, что дополнит окно иконкой "Информация". Полный список констант, управляющих поведением окна, можно увидеть в источнике [1].
5. В секции кода (.CODE
) ставим метку Start: (на самом деле, название может быть либо любым, либо зависеть от используемого компилятора, в TASM и MASM любое), это будет указывать компилятору на точку входа в нашу программу, т.е. говорить системе, откуда начинать выполнять код.
6. И ключевое слово end
с именем той же метки, между этими конструкциями будет находиться код нашей программы. Поскольку, дополнительных внутренних функций в нашем HelloWorld'е не предполагается - этого хватит, описание функций выходит за рамки данного небольшого урока.
Описание функции есть в справочнике по WinAPI, где оно дано в C-подобном стиле:
int MessageBox( [in, optional] HWND hWnd, [in, optional] LPCTSTR lpText, [in, optional] LPCTSTR lpCaption, [in] UINT uType );
И во всех современных компиляторах ассемблера под Windows есть всякие удобняшки, типа готовых макросов, которые ускоряют написание кода, позволяют не париться с параметрами, не писать простыни кода, но, не позволяют осознать, как оно все на самом деле работает. Это или макросы в MASM или режим IDEAL в TASM. Впрочем, все нормальные ассемблеры должны уметь работать и с удобняшками, и без них. А поскольку, пример у нас маленький, то стоит как раз все показать и объяснить, без всяких удобняшек.
Функции WinAPI работают по единому стандартизированному принципу - они достают входные параметры из стека, а результат (конкретное значение или адрес, по которому следует взять данные) пишут в регистр EAX
. Значение, возвращаемое функцией, нам в данном примере не понадобится, так что пока это опустим. Разберемся с параметрами.
Стек - это такой способ организации памяти, который работает по принципу "последний зашел, первый вышел". Т.е. стек можно представить, как стопку монеток (значения), которые находятся в баночке, чей диаметр соответствует размеру монетки, и туда можно за одну операцию или положить монетку, или достать только самую верхнюю. Т.е. последнюю положенную.
Запись в стек осуществляется командой push
, извлечение из стека - командой pop
.
Ясно, что человеку такой способ записи параметров интуитивно непонятен, потому в языках высокого уровня, сделали так, чтоб было удобно. Если же писать на чистом ассемблере, мы должны положить параметры в стек в обратном порядке:
push MB_INFORMATION ;Стиль Message box (Добавляем иконку "Информация")
push offset MSG_TITLE ;Заголовок Message box
push offset MSG_MESSAGE ;Текст в Message box
push 0 ;ID Вызывающего окна - его нет, устанавливаем в 0.
Далее вызываем саму функцию WinAPI:
call MessageBoxA
Теперь вызываем функцию, необходимую для корректного завершения программы. На вход она принимает только один параметр - код возврата. Мы ничего не делаем, кроме вывода MessageBox
'а, так что отдадим стандартный код нормального завершения - 0
.
push 0
call ExitProcess
Его здесь не будет, потому что написание консольного приложения под Win32, связано с тем, что всегда в определенный момент возникает в ассемблере - "много мелких, суетливых движений", как сказал классик по другому поводу. Написание консольного приложения под Windows усложнено, алгоритм там примерно такой:
1. Получить дескриптор стандартного устройства ввода-вывода
2. Проверить, доступен ли он программе.
3. Если недоступен, значит нас вызвали не из консоли, а из GUI, например, щелчком мыши.
4. Если 3 - неверно
5. Вывести текст на консоль
6. Если 3 - верно
7. Создать новую консоль, вывести текст, закрыть/освободить консоль.
MASM, в отличии от TASM умеет прописывать на этапе линковки флаг IMAGE_SUBSYSTEM_WINDOWS_CUI (3)
в заголовок PE-файла, это показывает ОС, что приложение расчитано на консольную подсистему, что, в свою очередь, избавляет программиста от необходимости вручную открывать консоль и устраивать дополнительные проверки. Система откроет консоль за нас. Но вернемся к этому в другой раз.
1. MessageBox function
2. Исходник и откомпилированная версия на GitHub
tasm-compile.txt (MEGA.NZ)
tasm-compile.txt (GitHub)
tasm-compile.txt (PasteBin)
tasm-compile-and-run.txt (MEGA.NZ)
tasm-compile-and-run.txt (GitHub)
tasm-compile-and-run.txt (PasteBin)
Точнее, конечно же, просто запуск стороннего компилятора, причем любого, имеющего поддержку командной строки (а они почти все такие, кроме совсем уж редких). Пока малому приятелю помогал написать Hello World на ассемблере, задолбался переключаться между редактором Far’а и батниками для сборки. MultiEdit или любимый FOTON, к которым можно привинтить компилятор, под Win7 не работают, но возможность запускать сторонние компиляторы оказалась у Notepad++
Современные версии Notepad++ позволяют установить плагин из самого редактора.
Заходим в Плагины —> Управление Плагинами… и в появившемся окне вбиваем в строку поиска NppExec
. Ставим напротив него галочку, и нажимаем ставшей активной кнопку Установить.
Notepad++ попросит перезагрузиться, скачает плагин и установит его.
После чего, в меню Плагины появится новое подменю NppExec.
В данном меню надо снять галочки напротив всех пунктов, выделенных по умолчанию, а поставить напротив пункта Follow $(CURRENT_DIRECTORY).
Написание скрипта
Осталось написать нужный скрипт для вызова компилятора и линковщика, покажу на примере TASM32.
Нажимаем F6 или в меню Плагины —> NppExec —> Execute NppExec Script…
Попадаем в пустое окно, где можно вводить команды скрипта:
Синтаксис скрипта мало отличается от BAT/CMD, за исключением того, что доступны внутренние команды Notepad++ и специальные внутренние переменные.
Для простейшего случая понадобится одна внутренняя команда и две специальных переменных. Сначала приведу пример скрипта, а потом опишу, что он делает.
npp_save
cd "$(CURRENT_DIRECTORY)"
N:\TASM\BIN\tasm32.exe /ml $(FILE_NAME)
if $(EXITCODE) !=0 goto exit
N:\TASM\BIN\tlink32 /Tpe /aa $(NAME_PART).obj,,,"N:\TASM\LIB\IMPORT32.LIB"
:exit
Скрипт выполняет компиляцию ассемблером TASM32 и линковку без запуска получившейся программы.
npp_save
— внутренняя команда Notepad++, сохранить текущий файл.
Примечание: Для нового файла появится окно сохранения.
Примечание #2: Стоит сохранять несохраненный файл под именем, содержащим только латиницу, а также выбрав нужный тип файла в окне сохранения. В противном случае могут быть глюки, зависящие от совокупности глюков плагина и компилятора.
cd
— аналогично команде BAT/CMD, перейти в указанную директорию.
"$(CURRENT_DIRECTORY)"
— внутренняя переменная с текущей директорией. Текущей директорией считается та, где сохранен файл, открытый в активной вкладке редактора (т.е. файл, который редактируем).
N:\TASM\BIN\tasm32.exe /ml $(FILE_NAME)
— вызов компилятора с нужными параметрами.
$(FILE_NAME)
— полное имя файла без пути, например, hello.asm
, если этот файл открыт на активной вкладке редактора.
if $(EXITCODE) !=0 goto exit
Команды if
и goto
работают почти также, как и в BAT-файлах. Некоторое различие в оформлении условий.
$(EXITCODE)
— внутренняя переменная, получающая код возврата ранее вызванного приложения. Аналог %ERRORLEVEL%
в BAT/CMD. Вызванные внешние компиляторы TASM/TASM32 завершаются с кодом 0
, если компиляция прошла успешно.
Далее вызывается линковщик:
N:\TASM\BIN\tlink32 /Tpe /aa $(NAME_PART).obj,,,"N:\TASM\LIB\IMPORT32.LIB"
$(NAME_PART)
— внутренняя переменная, содержащая имя файла без расширения и точки. Например, если на активной вкладке открыт файл hello.asm
, переменная $(NAME_PART)
содержит значение hello
.
В конце скрипта ставим метку :exit
— метка начинается с двоеточия (:
).
Чтобы пользоваться скриптом постоянно, нужно его сохранить (кнопка Save…) и ввести имя, например TASM COMPILE
:
Скрипт можно модифицировать так, чтобы после компиляции и линковки сразу выполнять программу:
npp_save
cd "$(CURRENT_DIRECTORY)"
N:\TASM\BIN\tasm32.exe /ml $(FILE_NAME)
if $(EXITCODE) !=0 goto exit
N:\TASM\BIN\tlink32 /Tpe /aa $(NAME_PART).obj,,,"N:\TASM\LIB\IMPORT32.LIB"
if $(EXITCODE) !=0 goto exit
$(NAME_PART).exe
:exit
Можно сохранить модифицированный скрипт под другим именем, например, TASM COMPILE AND RUN
.
При запуске плагин запоминает последний выполненный скрипт, и при новом запуске по F6 он уже будет открыт в окне NppExec, что, конечно же, удобно.
При выполнении скрипта откроется окно консоли, в котором можно наблюдать за ходом его выполнения:
NPP_SAVE: N:\SimpleAsm\hello.asm
CD: N:\SimpleAsm
Current directory: N:\SimpleAsm
N:\TASM\BIN\tasm32.exe /ml hello.asm
Process started (PID=7964) >>>
Turbo Assembler Version 5.0 Copyright (c) 1988, 1996 Borland International
Assembling file: hello.asm
Error messages: None
Warning messages: None
Passes: 1
<<< Process finished (PID=7964). (Exit code 0)
IF: $(EXITCODE) !=0 goto exit
N:\TASM\BIN\tlink32 /Tpe /aa hello.obj,,,"N:\TASM\LIB\IMPORT32.LIB"
Process started (PID=2784) >>>
Turbo Link Version 1.6.71.0 Copyright (c) 1993,1996 Borland International
<<< Process finished (PID=2784). (Exit code 0)
IF: $(EXITCODE) !=0 goto exit
hello.exe
Process started (PID=6360) >>>
<<< Process finished (PID=6360). (Exit code 0)
================ READY ================
NppExec хранит скрипты в каталоге
C:\Users\<username>\Application Data\Notepad++\plugins\config\
где:
<username>
— ваше имя пользователя.
В файлах:
npes_last.txt
— хранится последний использованный скрипт.
npes_saved.txt
— хранятся все скрипты, его можно забэкапить.
Компиляция программ с помощью Notepad++ — большая и несколько сумбурная статья на Habr.
В принципе, патч или кряк для программы можно сделать с помощью NSIS, конечно, это будет не классический патч, т.е., когда меняешь в исходном экзешнике несколько байт, а архив с готовым экзешником и сценарием установки. Но зато и возможностей больше, можно Реестр или INI-файлы подправить, например.
Но одна из главных задач любого патча, перед началом работы проверить, а не пропатчен ли файл уже. Делается это обычно так — берется контрольная сумма MD5 или CRC32 оригинального файла и сравнивается с заранее известной суммой. Если совпадает — файл наш, можно патчить. Можно и наоборот — сравнить контрольную сумму оригинального файла с известной контрольной суммой пропатченного, если они равны — файл уже модифицирован, сообщаем пользователю и завершаем работу.
Для получения MD5 в NSIS имеется плагин MD5 Plugin.
Скачиваем архив, копируем md5dll.dll
из директории ANSI
архива в директорию ANSI-плагинов NSIS (у меня C:\Program Files (x86)\NSIS\Plugins\x86-ansi\
), а из директории UNICODE
архива в директорию UNICODE-плагинов (C:\Program Files (x86)\NSIS\Plugins\x86-unicode
). Понятно, что пути к вашим каталогам плагинов могут отличаться, т.к. зависят от того, куда установлен NSIS/
Вычисление контрольной суммы строки:
#generate MD5sum of string
md5dll::GetMD5String "TestString"
Pop $0
DetailPrint "MD5 (string): [$0]"
Вывод:
MD5 (string): [5b56f40f8828701f97fa4511ddcd25fb]
Получение случайного хэша MD5:
#generate random MD5sum
md5dll::GetMD5Random
Pop $0
DetailPrint "MD5 (random): [$0]"
Вывод:
MD5 (random): [864fd151525efad56947f25fa3daeb75]
Получение контрольной суммы файла:
#generate MD5sum of file
DetailPrint "MD5 sum of file $EXEDIR\test\1.exe"
md5dll::GetMD5File "$EXEDIR\test\1.exe"
Pop $0
DetailPrint "MD5 (file): [$0]"
Вывод:
MD5 sum of file C:\!\Installers\MD5Sample\test\1.exe
MD5 (file): [03f3ba055d9f325c9abc90181f82657b]
Для более красивого кода сравнения, рекомендую подключить инклюд с макросами логических операторов LogicLib.nsh
(есть в комплекте NSIS):
!include LogicLib.nsh
Пример:
md5dll::GetMD5File "$EXEDIR\test\1.exe" Pop $0 md5dll::GetMD5File "$EXEDIR\test\3.exe" Pop $1 DetailPrint "Files $EXEDIR\test\1.exe" DetailPrint "and $EXEDIR\test\3.exe" DetailPrint "MD5: $0" DetailPrint "and $1" ${If} $0 == $1 DetailPrint "IS IDENTICAL!" ${Else} DetailPrint "IS DIFFERENT!" ${EndIf}
Пример вывода (сравниваются два одинаковых файла, а потом два разных):
Files C:\!\Installers\MD5Sample\test\1.exe
and C:\!\Installers\MD5Sample\test\2.exe
MD5: 03f3ba055d9f325c9abc90181f82657b
and 03f3ba055d9f325c9abc90181f82657b
IS IDENTICAL!
Files C:\!\Installers\MD5Sample\test\1.exe
and C:\!\Installers\MD5Sample\test\3.exe
MD5: 03f3ba055d9f325c9abc90181f82657b
and 7baeee10b3cd6c210c4fcd61b92b8e1e
IS DIFFERENT!
Если файл отсутствует, то функция md5dll::GetMD5File
может выдать непредсказуемый результат, строку случайных символов, поэтому, перед использованием md5dll::GetMD5File
следует проверять наличие и доступность файлов.
Библиотека:
— Описание на официальном сайте: MD5 plugin
— Скачать с официального сайта
— Зеркало
— Копия (v 0.5) на Mega.nz
Винно-исторический музей
Да, понадобилась мне такая программа под Win32, которая совсем ничего не делает. Запускается, и сразу завершает работу, не открывая окна консоли и не создавая окно GUI. Для чего, расскажу в другой раз. Встал вопрос, на чем писать. .NET не подходит — слишком уж за такой программой Framework таскать, был Lasarus, но, если честно, не понял, как там все правильно сделать. И тут осенило, есть же TASM, идеально подходящий для такой задачи, будет максимально маленький экзешник, требующий только одну функцию из WinAPI — ExitProcess
. Самое то! Правда, на ассемблере я кодил в лохматых годах, так что пришлось немного повспоминать.
.386
.MODEL FLAT
extrn ExitProcess:proc
.DATA
szHelp DB 'This program start and end'
.CODE
Start:
nop
nop
nop
push 0
call ExitProcess
end Start
.386
— директива, позволяющая ассемблировать инструкции i386-го процессора, нам хватит.
.MODEL FLAT
— выбор стандартной в Win32 модели памяти (FLAT
)
extrn ExitProcess:proc
— директива extrn
позволяет использовать в программе функцию (тут ExitProcess
) из внешней библиотеки, которую подключим на этапе линковки.
Библиотека IMPORT32.LIB
, содержащая основные функции WinAPI должна быть в комплекте TASM.
.DATA
— начало сегмента данных, в принципе, в этой программе можно его просто определить и не заполнять, но я определю в нем строку, которая будет храниться прямо в в экзешнике, как его описание. Можно открыть экзешник по F3 в Far’е, например, и увидеть ее. При работе программы строка использоваться не будет.
szHelp DB 'This program start and end'
— та самая строчка.
.CODE
— Сегмент кода.
Start:
— метка, обозначающая точку входа в программу. Можно назвать хоть как (Start
, Main
и т.д.).
nop
— пустая операция, процессор в буквальном смысле делает ничего. Можно пропустить, но пусть будет.
push 0
— кладем в стек код возврата, который будет использован функцией ExitProcess
.
end Start
— конец основной функции программы.
Компиляция:
tasm32 /m simple.asm
где:
/ml
— учитывать регистр символов при компиляции.
simple.asm
— имя файла с исходником.
Получилось:
Assembling file: simple.asm Error messages: None Warning messages: None Passes: 1
Будет создан файл simple.OBJ
Линковка:
tlink32 /Tpe /aa simple.OBJ,,,IMPORT32.LIB
где:
/Tpe
— создать на выходе Win32 PE-файл (Стандартный формат 32-х битного экзешника, начиная с Windows 95).
/aa
— Использовать WinAPI
Примечание: Библиотека IMPORT32.LIB
должна лежать в том же каталоге, где и simple.OBJ
, или прописывайте полный путь к файлам
Writing Win32 programs in assembly language using TASM:
— Читать на tolik-punkoff.com
— Читать на lj.rossia.org
— Скачать с Mega.NZ
— Скачать с Google.Drive
По-прежнему, чиним деньгополдощательные терминалы и всякие прочие АРМ, потому понадобилось, заметка от склероза, чтоб не забыть, да и другим полезно будет.
Рассматриваем способы, как ее вызвать, если доступа к физической клавиатуре нет совсем.
1. ПУСК —> Все программы —> Стандартные —> Специальные возможности —> Экранная клавиатура
2. Добираемся мышекликом до экзешника: %windir%\system32\osk.exe
Где %windir%
— каталог с установленной Windows (обычно C:\Windows
).
Если надо вызвать программу с командной строки (для справки), то соответственно, команда: osk
Примечание: Экранная клавиатура, как и физическая, поддерживает только раскладки клавиатуры (языки ввода) установленные в системе, т.е., если русский язык, например, в системе не установлен совсем, то и переключиться на наго нельзя.
Самый простой. Не пользоваться для переключения языка ввода и раскладки экранной клавиатурой, все спокойно можно делать мышью, с помощью значка индикатора клавиатуры в системном трее.
Щелкаем те же клавиши, которые установлены для переключения клавиатуры в системе, и не задерживаясь, нажимаем ту, с которой начали. Т.е. если переключение клавиатуры настроено на Alt+Shift, то на экранной клавиатуре жмем Alt, потом Shift (или наоборот, сначала Shift потом Alt), а потом возвращаемся к первой клавише, если первой нажимали Alt — нажимаем Alt второй раз, если первый раз нажимали Shift — второй раз нажимаем Shift.
Если в системе установлена комбинация Ctrl+Shift, действия аналогичны, только нажимаем соответствующие клавиши на экранной клавиатуре
Переключение раскладки:
Раскладка переключилась:
ТЕЛЕМАРКЕТ!