/
Author: Антонов В.
Text
*ьмгм
ВВЕДЕНИЕ.
Почему эта книга появилась
Когда я говорю людям, что пишу книгу «ЮА Рго для чайников», первая реакция
почти всегда одинаковая:
«Но ведь такая книга уже есть! Дэн Салливан, 2004 год...»
И это правда. Книга Салливана была отличной для своего времени, Она научила
тысячи людей основам реверс-инжиниринга. Я сам когда-то начинал с неё.
Но проблема в том, что с 2004 года изменилось ВСЁ. Мир технологий ушёл
вперёд настолько, что книгу 2004 года можно читать разве что из исторического
интереса.
Тек!
I 2004 * 2026: 1 ЧТО ИЗМЕНИЛОСЬ I
Архитектуры: х8б (32-ЫЮ -> х8б, хб4, АКМ, К1$С=и |
Платформы: + Н1пс1о^ 11, Ипих, шасОЗл АпЦгоЮ, 10$л ЮТ |
Инструменты: Ассемблер -* Е5 (декомпиляция в С)
читали руками читаем С-код
Цена: I- _ . Книга + ЮА Рго от $2000 (есть бесплатные аналоги) 1
Именно поэтому я и написал эту книгу. Не чтобы заменить Салливана, а чтобы
дополнить его тем, чего там нет, и переосмыслить то, что устарело. Если вы читали
Салливана в 2004 году — вы молодец. Но если вы читаете его сегодня — вы
теряете время, потому что 80% материала устарело.
Чем эта книга уникальна?
Вот шесть главных отличий от всего, что вы могли читать раньше:
1. Р5 — первая глава, а не последняя
В большинстве старых книг ассемблер изучают месяцами. Сначала учат регистры,
потом стек, потом команды... и только к концу книги человек начинает понимать,
что же делает программа.
Я поступаю иначе. Я говорю: нажмите Р5 и читайте С-код. Декомпилятор делает
90% работы за вас. Всё остальное — это доводка и понимание нюансов.
Вот как это выглядит на практике. Вместо того чтобы разбирать десятки строчек
ассемблера:
Ьеи!
ризЬ еЬр
шоу еЬр, егр
5иЬ езр, 101т
мои еах, [&Ьр+8]
ри&1т еэх
са11 _5Тг1еп
эдй езр, 4
стр еах, 5
]П2 бИогТ Та!1
ризЬ оТТае!: разз
ризЬ [еЬр+8]
са 11 -5-Ьгстр
Вы нажимаете Е5 и видите это:
ВООЬ СНескРаз&шог-с! (сопз1: сЬаг4 ±прмИ} {
1Т (Б1г1еп(1пр|Л) == 5) {
(з^гстр(1пр|Лл "Бесге*1 ) == б) {
ТД11Е;
}
}
геТигп ГА15Е;
Разница очевидна. Вместо того чтобы учить ассемблер полгода, вы учитесь читать
С-код (который вы уже знаете) и доводить его до ума. Это экономит МЕСЯЦЫ
обучения.
Д Важно: Это НЕ исходный код, а псевдокод. Он очень похож на Сг но может
содержать странные переменные (VI, у2, уЗ), неоптимальные конструкции и
ошибки в типах. Но для новичка это в 10 раз понятнее ассемблера.
2. Никакой «священной войны» инструментов
В интернете полно фанатов, которые кричат: «ЮА — это святое!», «СЫс!га —
убийца ЮА!», «Только Яас1аге2 для настоящих хакеров!».
Мне это неинтересно. Я не буду говорить, что один инструмент лучше другого. Я
покажу, когда и что лучше использовать, и как заставить их работать вместе.
Вот краткое сравнение:
Тех!
ВЫБОР ИНСТРУМЕНТА | 1
| ЮА РНО 1 Лучший декомпилятор, 10+ архитектур, огромное количество плагинов X Дорогой (от $2000), сложный интерфейс (У Если есть бюджет и нужна скорость |
| ЙНЮВА (М5А) 1 Бесплатно, хороший декомпилятор, современный интерфейс X Медленнее, меньше плагинов (У Если нет бюджета или работаете один
В1МАЙУ КТМ1А / Недорого / бесплатно, красивый интерфейс
[ С1ПТЕИ 1 X Слабый декомпилятор^ меньше функций О Если любите экспериментировать 1
Мой совет. Если есть возможность — берите ЮА Рго. Если денег нет — ЮА Егее
или СЫска. В этой книге я показываю приёмы, которые работают в ЛЮБЫХ
дизассемблерах. Просто ЮА — самый удобный для обучения.
3. Практика на реальных задачах
Теория без практики — это мёртвый груз. Я сам учился по книгам, где было 500
страниц теории и 10 страниц примеров. Это неправильно.
В этой книге каждая глава заканчивается конкретным практическим заданием. Вы
не просто читаете — вы сразу применяете.
I-----------------------------------------------------------------------1
| СТРУКТУРА КАЖДОЙ ГЛАВЫ |
I-----------------------------------------------------------------------1
1. ТЕОРИЯ (29%) * Что это, зачем нужно, как работает
2. ДЕМОНСТРАЦИЯ -» Я показывай на реальном примере
(39%) пошагово
3. практика (50%) -» Вы скачиваете сгаскше и делаете
самостоятельно (НЕ ПОДГЛЯДЫВАЯ!)
Что вы будете делать на практике? Разбирать сгаскпле-задачи (специально
созданные для обучения), находить проверки паролей и обходить их, исправлять
баги в программах без исходников, анализировать реальные примеры кода,
извлекать алгоритмы и криптографические ключи.
4. Все современные платформы
Книга Салливана учила работать только с \Мпс1(Ж5-ЕХЕ. В 2004 году этого было
достаточно. Сегодня — катастрофически мало.
Вы будете работать с:
I I ПЛАТФОРМЫ для анализа 1 1
1 1 1 Е. И1МСЮЫ5 -• ЕХЕ, ОН, драйверы
Ц АМЗНОЮ -> Нативные библиотеки .50, АЙМ/АЙМ64
0 Ю5/тас05 -» Приложения, МасИ-О
| А ИМ11Х Е 1-Е-файлы, серверы
К ВСТРАИВАЕМЫЕ * Прошивки роутеров, микроконтроллеры.
| СИСТЕМЫ АРМ, М1Р5, ЙТЗС-У, 1оТ-устройства | 1 1
В этой книге я учу работать со ВСЕМИ этими платформами.
5. Плагины и автоматизация — не бонус, а обязаловка
В старой школе реверс-инжиниринга считалось, что «настоящий» аналитик должен
делать всё вручную. Что плагины — это для слабаков.
Этот подход умер. Сегодня объёмы кода такие, что без автоматизации вы просто
утонете.
Ъек!
РУЧНАЯ РАБОТА | АВТОМАТИЗАЦИЯ
1 | БЕЗ ПЛАГИНОВ С ПЛАГИНАМИ
(ручная работа) | (автоматизация)
г Искать функции по адресам + ЕИКТ / Ситтпа (авто)
Переименовывать по одной •+ Скрипт на ₽у1Ьоп
Искать строки глазами -* 511ГП+Е12 (мгновенно)
Восстанавливать структуры 1 -* Плагин за секунду
5-10 часов работы 15-30 минут работы
I__________________________________________________________________I
Автоматизация — не для ленивых, а для умных. Экономьте время на рутине,
чтобы тратить его на сложные задачи.
Какие плагины я покажу? Кеура^сР» (патчинг), Е1пс1СгурГ (поиск криптографии), ЮА
РуИтоп (скрипты), 1_игп1па (облачное распознавание), ЕЫНТ (библиотеки).
И я покажу, как писать свои скрипты на РуИзоп уже в четвёртой главе.
6. Честный разговор об ИИ
В 2026 году невозможно игнорировать искусственный интеллект. Нейросети
(СНаТбРТ, С1аис1ег СорНо!) уже умеют анализировать код, объяснять ассемблерные
инструкции и даже предлагать патчи.
Но они не идеальны.
Тех!
I------------------------------------------------------------------1
I ИИ: помощник или ВРАГ? I
I------------------------------------------------------------------1
I ГДЕ ПОМОГАЕТ: |
• Объясняет незнакомые инструкции
• Переименовывает сотни функций за минуту
• Генерирует комментарии
• Ищет паттерны
I------------------------------------------------------------------I
| X ГДЕ ВРЁТ: |
• Уверенно ошибается в деталях
» Придумывает несуществующие функции
• Пропускает нюансы безопасности
• Предлагает патчи, которые сломают программу
__________________________________________________________________
Мой подход. Пользуйтесь ИИ как помощником, НО: всегда перепроверяйте его
выводы, учитесь понимать код сами, используйте ИИ для обучения, а не для
замены собственного мышления.
Кому нужна эта книга?
г.ехт
I-----------------------------------------------------------------------------------------1
КОМУ НУЖНА ЭТА КНИГА
3 новичок + От !|что такое дизассемблер*1 до анализа сгаскте-задач. Объясняю КАЖДЫЙ ШАГ.
| а РАЗРАБОТЧИК -* Понять * как код выглядит в ассемблере, находить баги без исходников*
| • СПЕЦИАЛИСТ -> Анализ малвари, обход анти-отладки,
1 ПО БЕЗОПАСНОСТИ работа с упаковщиками.
| а студент * Реальные навыки., которые ценятся на рынке труда.
| И ЛЮБОПЫТНЫЙ -» 1 Заглянуть "под капот11 программ^ понять, как они работают> 1
Что вы НЕ найдёте в этой книге
Полного курса ассемблера. Я дам основы, чтобы вы понимали, что видите в ЮА.
Но учить писать на ассемблере с нуля я не буду. ПОЧЕМУ? ЮА САМ переводит
ассемблер в С через Е5. Глубокие знания нужны только в 10% случаев.
Инструкции по взлому игр или незаконных действий. Эта книга — для
обучения. Все примеры —легальные сгескппе-задачи и тестовые программы. Все
знания — ТОЛЬКО для законных целей.
Магических способов за 5 минут. Реверс-инжиниринг — это интеллектуальный
труд. Я научу вас НАХОДИТЬ быстро, но понимать найденное нужно вам.
Справочника всех инструкций процессора. Это есть в интернете. Я даю ТОЛЬКО
те инструкции, которые реально встречаются новичку: шоу, ризЬ, рор, саП, геХ, стр,
ТеБГ, ]тр^2, |п2, адс1г зиЬ, и т.д.
Что вам понадобится для работы
Тех!
1 1 МИНИМАЛЬНЫЙ СТАРТОВЫЙ НАБОР |
| 1. КОМПЬЮТЕР Ы1пааы5 / Цлих / тасСБ Минимум: 4 ГБ ВАМ, 1 ГБ места
2. ЮА РКО или | АЛЬТЕРНАТИВА ЮА Рго (от $2000) ЮА Егее (бесплатно) БЫс1га (бесплатно) 1 1 1
| 3. БАЗОВОЕ ЗНАНИЕ С или С++ Перемен ные, функции, ус ло ви я, строки, указатели. (Если нет - прочитайте книгу ЦИКЛЫ, за выходные)
| 4. ПРИМЕРЫ ДЛЯ ПРАКТИКИ сгасктеь.опе, КооТ-те.ог^ (ссылки даю е каждой главе) 1 1
| 5* ЖЕЛАНИЕ УЧИТЬСЯ | И НЕ СДАВАТЬСЯ 1 Ошибки - нормально. Главное - ДЕЛАТЬ, а не просто 1 читать. 1
Как читать эту книгу
Я предлагаю три маршрута в зависимости от вашего уровня:
гехт
г----------------------------------------------------------------1
ВЫБЕРИТЕ СВОЙ МАРШРУТ
И 11 АБСОЛЮТНЫЙ НОЛЬ"
Если НИКОГДА не видели ЮА:
| Глава 1 > 2 3 4 * 5 |
После Главы 5 вы найдёте проверку пароля в любом файле*
Время: 2-3 часа.
I---------------------------------------------------------------------1
| 0 "УВЕРЕННЫЙ ПОЛЬЗОВАТЕЛЬ" |
Если что-то слышали, но не работали:
Глава 5-»б->7-»8-»9-»10
Пропускаете установку * сразу к реальной работе.
Время: 5-6 часов.
I-----------------------------------------------------------------—I
| • "БЫВАЛЫЙ" |
Если работали в бЫЗга, Кас1аге2, ОПуРЬ^:
| Глава 14 * 15 -» 16 -» 10 |
Сразу к плагинам, скриптам и автоматизации.
Время; 2-3 часа.
____________________________________________________________________
Как работать с книгой: инструкция
1ех1
I---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------1
ИНСТРУКЦИЯ ПО РАБОТЕ
ШАГ 1. ЧИТАЙТЕ ТЕОРИЮ 1 Прочитайте главу♦ Поймите общую концепцию. Не пытайтесь запомнить всё*
[ ШАГ 2. СМОТРИТЕ ДЕМОНСТРАЦИЮ Скачайте файл (ссылку даю). Повторите за мной шаг за шагом. 1 1 1
I ШАГ 3. ВЫПОЛНЯЙТЕ ЗАДАНИЕ (ЭТО ГЛАВНОЕ!] Скачайте сгаскте. Откройте в ЮА. Сделайте САМОСТОЯТЕЛЬНО. 1 НЕ ПОДГЛЯДЫВАЙТЕ в ответ! 1 I I I
ШАГ 4. ЭКСПЕРИМЕН- ТИРУЙТЕ измените что-нибудь* Посмотрите л что изменится. Сломайте и почините. I 1
Л Важное правило: НЕ ЧИТАЙТЕ книгу как роман. Глава -> задание -• следующая
глава. Только так вы НАУЧИТЕСЬ.
Заключение введения
Итак, вы держите в руках книгу, которая:
• Не повторяет устаревшие материалы 20-летней давности
• Учит использовать современные инструменты и подходы
* Делает упор на практику, а не на теорию
* Учит работать с любыми платформами и архитектурами
• Объясняет сложные вещи простыми словами
Я верю, что каждый мюжет освоить ЮА Рго. Для этого не нужно быть гением или
программистом-ветераном. Нужно только желание, немного времени и пошаговое
руководство, которое вы держите в руках.
Давайте начнем!
ГЛАВА 1. Что такое ЮА Рго и зачем она нужна?
1.1, ЮА Рго — это не магия, это инструмент
Представьте, что вы получили книгу, написанную на неизвестном языке. Вы не
можете её прочитать, но вам нужно понять, о чём она. Что вы сделаете? Попросите
переводчика? Найдёте словарь? Попробуете угадать по картинкам?
ЮА Рго делает то же самое с программами.
ВХОД:
Бинарный файл
(ЕХЕ, ВЩ
прошивка,.,)
"Книга на
неизвестном
языке"
ПРОЦЕСС:
Дизассемблирование +
декомпиляция
4.
ЮА "переводит"
машинный код
в читаемый вид
ВЫХОД:
Ассемблерный код +
С-псевдакод
г
"Перевод книги"'
на понятный
язык
ЮА Рго — это интерактивный дизассемблер. Она не просто показывает код, она
позволяет вам с ним работать: переименовывать, комментировать, перестраивать,
искать, анализировать.
Вот ключевые термины, которые нужно запомнить:
Дизассемблер — превращает машинный код в ассемблер. Переводит "О и 1" в
"глох, ри$1х саП".
Декомпилятор — превращает ассемблер в С-подобный код. Переводит "тох,
ри5К, са1Г в "И, Гог, $1гстр".
Интерактивный — вы можете редактировать и дополнять анализ. Вы не просто
смотрите — вы работаете.
1.2. Зачем вам это нужно?
Вопрос, который вы задаёте себе прямо сейчас: "Зачем мне изучать ЮА Рго?" Вот
ответы для разных ситуаций:
Вы хотите понять, как работает программа:
У вас чет исходников, но нужно разобраться в логике
Вы нашли подозрительный файл и хотите проверить его
Вы изучаете вредоносное ПО и хотите понять, что оно делает
Вы ищете ошибки и уязвимости:
Программа падает, а исходников нет — найдите место падения
Вы тестируете безопасность и ищете уязвимости
Хотите понять, как обойти защиту (в легальных целях)
Вы исправляете программы без исходников:
Старое ПО больше не поддерживается, но нужно исправить баг
Нужно изменить поведение программы (патчинг)
Восстановление утерянного исходного кода
Вы учитесь реверс-инжинирингу:
Это востребованный навык в И Б и разработке
Вы хотите понять, как работают компиляторы и ОС
Это просто интересно!
1.3. Почему именно ЮА Рго?
На рынке есть несколько инструментов для реверс-инжиниринга. Почему я выбрал
ЮА Рго для этой книги?
ЮА Рго — это стандарт. В индустрии его используют все: от исследователей
безопасности до разработчиков антивирусов. Это как РЬо1о51тор для дизайнеров
или Ехсе! для финансистов. Если вы умеете работать в ЮА, вы сможете работать где
угодно.
Вот краткое сравнение основных инструментов:
Инструмент Плюсы Минусы Дорогой (от
Лучший декомпилятор, 10+ архитектур, ЮА Рго тысячи плагинов 52000), сложный интерфейс
Бесплатно, хороший декомпилятор, СЫс!га (М5А) н к современный интерфейс Медленнее, меньше плагинов
Втагу №п]а / Недорого, красивый интерфейс С и Мег Слабый декомпилятор
Но есть нюанс. Если у вас нет бюджета на ЮА Рго, не отчаивайтесь:
ЮА Ргее — бесплатная версия с ограничениями (нет декомпилятора, только 32-
бит, но для обучения хватит)
6Ыс1га — полноценная бесплатная альтернатива с декомпилятором
В этой книге я показываю приёмы, которые работают в ЛЮБОМ дизассемблере.
Просто с ЮА удобнее учиться.
1.4. Статический У5 Динамический анализ
Это фундаментальное различие, которое нужно понять с самого начала.
Ьё к!
СТАТИЧЕСКИЙ АНАЛИЗ
(ЮА Рго - основа)
Анализируете ФАЙЛ,
не запуская его
Читаете код, ищете
строки, переименовываете
функции
БЕЗОПАСНО - программа
не выполняется
ДИНАМИЧЕСКИЙ АНАЛИЗ
(Отладчик в ЮА)
Запускаете ПРОГРАММУ
и смотрите^ что она
делает в реальном времени
Ставите брейкпоинты,
смотрите регистры,
трассируете
Программа выполняется,
можно увидеть данные
е реальном времени
Когда что использовать?
Статический анализ (90% времени):
* Быстро понять, что делает программа
• Найти проверку пароля или алгоритм
- Работать с вредоносным ПО (не запуская его!)
Динамический анализ (10% времени):
• Понять, почему программа падает
* Увидеть данные в реальном времени
• Обойти анти-отладку
• Разобраться в сложной логике, которую статикой не понять
В этой книге мы начинаем со статического анализа. Именно в нём ЮА Рго сильна, и
именно с него начинают все профессионалы. Динамический анализ (отладка) мы
рассмотрим в Части III.
1.5. Что вы сможете делать после этой книги?
Вот ваш путь от новичка до уверенного пользователя:
После Главы 5 (первые 2-3 часа):
Открыть любой простой файл в ЮА
Найти все строки в программе (5ЫТ1Ч-Р12)
Нажать Е5 и прочитать С-код
Найти проверку пароля
Переименовать функцию (И)
Добавить комментарий (;)
После Части II (статический анализ):
Работать со структурами и типами данных
Понимать графы переходов
Восстанавливать алгоритмы по псевдокоду
Использовать перекрёстные ссылки (X)
Работать с библиотеками (ЕН КТ)
После Части III (динамический анализ):
Ставить брейкпоинты
Смотреть регистры и стек
Трассировать выполнение
Патчить программы прямо в ЮА
После Частей 17-71 (расширенные навыки):
Писать скрипты на Ру1Ьоп
Работать с АКМГ Апдго1б, Ю5
Анализировать вредоносное ПО
Работать с упаковщиками и обфускацией
Использовать ИИ как помощника
1.6, Первое знакомство: что вы увидите при запуске
Когда вы впервые откроете ЮА Рго, вас встретит окно с несколькими панелями. Не
пугайтесь! К концу второй главы вы будете чувствовать себя как дома.
Вот краткая схема интерфейса:
сехт
I | МЕНЮ И ПАНЕЛЬ ИНСТРУМЕНТОВ ЕПе | Ес111= | Зитр | 5еагсИ 1 1_ ОеЬи^ег | ... 1 1 1 -I
1 1 | ОКНО I | ФУНКЦИЙ 1 ОСНОВНОЕ ОКНО с кодом (01заз5етЫу У1еы) 1 1 1
| 5иЬ_401000 I | $иЬ_401020 | 1 | .сехг:401000 ризЬ | ЛехТ:401001 той еЬр еЬр, езр 1 1 1 1 1 1
_<па1п | .1ех1:401003 зиЬ е^р, 10Н
| .1ех1:401006 ПОУ еах, [еЬр+В]
_51ГСГПр | .Сех!:401009 РЦБЬ еах
1 | ЛехХ;40100А саН _51:г1еп
I I ’---------------------------------------------------------------1 I
I---------------1---------------------------------------------------------1
[ ОКНО ВЫВОДА (ОЛри! Щпйоы) |
| ЮА 15 зпа1у51п§ М1е Хпри! Н1е...
Еоипй 123 •РипсИопз.
I_________________________________________________________________________I
Главные элементы интерфейса:
1. Меню и панель инструментов — сверху. Там всё, что можно делать: открыть
файл, поискать, запустить отладку.
2. Окно функций (ЕипсНопк УУтбочлО — обычно слева. Это список всех функций,
которые ЮА нашла в программе. Как оглавление книги.
3. Основное окно с кодом (□|5ахьетЫу У|еш) — в центре. Здесь вы видите
ассемблерный код и (после нажатия Р5) С-псевдокод.
4, Окно вывода (ОиТри! УУтбоуу) — внизу. Сюда ЮА пишет, что она делает:
"Найдено 123 функции", "Применяю ЕН КТ-сигнатуры" и т.д,
5. Окно строк (51Нпд$ М/тс1ои/) — открывается по 5ЫЛ+Е12. Здесь все текстовые
строки из программы.
Пока запомните только это;
• Функции — это "главы" книги. Ищите нужную функцию по названию.
• Код — это "текст" книги. Его вы читаете и анализируете.
• Строки — это "ключевые слова". Ищите их, чтобы быстро найти что-то важное
(ошибки, пароли, сообщения).
1.7. Краткий словарь терминов
Прежде чем мы двинемся дальше, вот несколько терминов, которые вам
встретятся в книге. Не пытайтесь запомнить всё сразу — просто знайте, куда
заглянуть, если что-то непонятно.
• Бинарный файл — готовый файл программы, который можно запустить на
компьютере (ЕХЕ, ОЫ_, Е1.Е, АРК).
• Ассемблер — язык, который понимает процессор. Состоит из команд вроде глох,
ризЬ, саН.
• Машинный код — ассемблер в "цифровом" виде (байты). То, с чем реально
работает процессор.
• Дизассемблирование — перевод машинного кода в ассемблер (это делает ЮА).
• Декомпиляция — перевод ассемблера в С-подобный код (это делает Е5 в ЮА).
Псевдокод — С-подобный код, который ЮА показывает после Б5. Он похож на С,
но это не настоящий исходник.
Функция — кусок кода, который что-то делает, У неё есть имя (например, _тат
или 5иЬ_401000).
Адрес — место в памяти, где находится код или данные. Например, 0x401000.
Перекрёстная ссылка (хгеГ) —указание на то, где ещё используется эта функция
или переменная.
1.8. Мифы о реверс-инжиниринге (разрушаем сразу)
Прежде чем мы двинемся дальше, давайте развеем несколько мифов, которые
могут вас пугать.
Миф 1: "Для этого нужно быть хакером"
Нет. Реверс-инжиниринг— это инженерная дисциплина. Как механика или
электроника. Вы учитесь читать чужой код, понимать логику, находить ошибки.
Никакого "взлома" в этом нет, если вы не используете знания для незаконных
целей.
Миф 2: “Нужно знать ассемблер наизусть"
Нет, Благодаря Б5 (декомпилятору) вы читаете С-код, который гораздо проще.
Ассемблер нужен только для понимания нюансов, и это приходите практикой.
Миф 3: “Это слишком сложно для новичка"
Нет. В этой книге я покажу, что 90% работы — это простые действия: поиск строк,
нажатие Г 5, переименование функций. Сложное приходит позже и постепенно.
Миф 4: "ЮА Рго — только для профессионалов"
Нет. Да, у ЮА есть сложные возможности, но базовые вещи доступны любому, кто
умеет читать С-код. Вы начнёте с простого и будете расти.
1.9. Что дальше?
Теперь, когда вы знаете, что такое ЮА Рго и зачем она нужна, мы готовы перейти к
самому важному — установке и первому запуску.
В Главе 2 вы:
Скачаете и установите ЮА (или альтернативу)
Настроите интерфейс под себя
Загрузите первый файл
Увидите, как ЮА анализирует программу
Это будет ваш первый шаг в мир реверс-инжиниринга.
Итоги главы
ЮА Рго — это интерактивный дизассемблер и декомпилятор
Она переводит машинный код в читаемый ассемблер и С-псевдокод
Главная суперсила ЮА — клавиша Е5 (декомпиляция)
Статический анализ (без запуска программы) — основа работы
ЮА — это стандарт индустрии, но есть бесплатные альтернативы
Реверс-инжиниринг доступен каждому, кто готов учиться
Готовы? Идём дальше!
ГЛАВА 2. Установка и первый запуск
2.1. Выбор версии ЮА
Прежде чем что-то устанавливать, давайте разберёмся, какая версия ЮА вам
нужна. Это сэкономит вам время и нервы.
КАКУЮ ВЕРСИЮ ЮА ВЫБРАТЬ?
ЮА РКО (платная, от $2000)
т I
Полный декомпилятор (Р5)
Все архитектуры (х8бл хб4, АЯН, М1Р5,
Все плагины и обновления
Техническая поддержка
X Дорого
ЮА НОМЕ (платная, от $1000)
I-----------------------------------------------------------------1 I
| Есть декомпилятор (Е5)
| Ограниченное число архитектур (выбираете одну)
| X не для коммерческого использования
1-----------------------------------------------------------------' I
I
ЮА РЙЕЕ (бесплатно)
| Бесплатно
| Есть дизассемблер
| | X НЕТ ДЕКОМПИЛЯТОРА (самое важное!) | |
| | X Только 32-бит | |
X Ограниченные возможности
I 1------------------------------------------------------------' I
I
| 6НЮЙА (бесплатно от МБА)
I I------------------------------------------------------------1
| Полностью бесплатно
| Отличный декомпилятор (почти как Е5)
| Все архитектуры
| Современный интерфейс
| X медленнее ЮА
I 1------------------------------------------------------------' I
I___________________________________________________________________I
Мой совет для новичка:
Если у вас есть бюджет — берите ЮА Рго. Это самый быстрый путь к результату.
Если бюджета нет — ставьте (ЗЫс1га. Она бесплатна и даёт почти те же
возможности, что и ЮА Рго (включая декомпилятор). В этой книге я показываю
приёмы, которые работают в обоих инструментах.
ЮА Ргее я НЕ рекомендую для обучения, потому что без декомпилятора (Р5) вы
будете вынуждены читать ассемблер вручную, а это сильно замедлит ваше
обучение.
2.2. Установка ЮА Рго
Если вы выбрали ЮА Рго, вот инструкция по установке.
Шаг 1. Скачайте дистрибутив
Зайдите на официальный сайт Нех-Кау5: ичы.нех-гауз.сот/ма-рго/
Вам нужен установщик для вашей операционной системы:
1с1а_рг'о_$е1ир .ехе
1_1Пих: 1^э_рго_5е1ир. гип
тасОБ: 1<1а_рго_5е1:ир.(1тЕ
Шаг 2. Запустите установку
На Мпбот просто запустите .ехе и следуйте инструкциям мастера установки. На
□пих дайте права на выполнение: сГ«юд +х 1с1а_рго_5е1ир.гип и запустите. На тасО$
откройте .±пе и перетащите ЮА в папку АррНса^опз.
Ьех’Ь
ВАЖНЫЕ МОМЕНТЫ ПРИ УСТАНОВКЕ
1 1- Путь установки Оставьте по умолчанию (С:\Рго^гат Р11ез\ЮА Рго) Не используйте пути с пробелами и русскими буквами
1 Компоненты Установите ВСЕ компоненты Особенно: Нех-КауБ ОесогпрПег (это ваш ГБ*)
1 Лицензия Если у вас есть файл лицензии (Леу) - скопируйте его | в папку с ХОД, Если нет - используйте пробную &ерсию (обычно 30 дней) или ЮА Ргее.
1 4- 1 Антивирус Временно отключите антивирус на время установки. Некоторые антивирусы ложно срабатывают на ЮА. 1
Шаг 3. Первый запуск
После установки запустите ЮА Вас встретит окно выбора файла. Пока просто
закройте его (Сансе!) — мы разберём загрузку файлов в Главе 4.
2.3, Установка бЬШга (если вы выбрали её)
Если вы выбрали бесплатный путь, вот инструкция по установке бЫс1га.
Шаг 1. Скачайте бНдга
Зайдите на официальный сайт: еИ1с1га-5ге,оге
Скачайте последнюю версию для вашей ОС:
Мпйоууз: .гхр архив
□пих: .21р архив
тасО$: .г!р архив
Шаг 2. Распакуйте архив
Распакуйте архив в любую удобную папку. Например:
\Мпс1оУУ$: СДвЫдга
□пих: /Ьоте/и5ег/§Ыс1га
ГПасОЗ: /АррИсаТХопз/зЫ^га
Шаг 3. Установите 1ауа
бЫдга работает на Ьуа. Убедитесь, что у вас установлена )ауа 17 или выше:
УУ!пс1о«5; скачайте С ]ача.сот
□них: 5ис1о ар1 хпзтаП орел}0к-17-Зйк
тасОЗ: Ьгеи 1пзЪа11 ореп]с1к@17
Шаг 4. Запустите СЫс1га
Запустите файл дН10гаЯип (Шпбот: . Ьат, Ыпих/гпасОЗ: .5Г1).
2.4. Настройка интерфейса для новичка
ЮА Рго имеет сложный интерфейс, но его можно настроить так, чтобы он стал
понятным. Вот что я рекомендую сделать сразу после установки.
Настройка 1: Включить тёмную тему (если любите)
* Третей + Озгк
Это сохранит глаза при долгой работе.
Настройка 2: Показать все нужные окна
По умолчанию не все окна открыты. Откройте их:
^ех-г
У1еы -» Ореп 5иЬу1е«$ -» Рипс^±оп5 (открыть окно функций)
У1еа Ореп 5иЬу1еы5 -* 5Тг1п^5 (открыть окно строк)
У1еы -» Ореп 5иЬи1еы5 -* ОиТриТ (открыть окно вывода)
Настройка 3: Настроить шрифт
Сделайте шрифт побольше, чтобы не напрягать глаза:
ОрТхопз -» ЕопТ * СЬоове Топ!
Выберите моноширинный шрифт (Соп$о1а5, Соипег Ме«у, ^1:Вга!п5 Мопо) размером
12-14.
Настройка 4: Включить '‘синхронизацию" окон
Это удобная функция: когда вы кликаете на функцию в окне функций, она
автоматически показывает её в основном окне,
ШпЛом + ЗулсЬгопгге -» ЗупсЬгогЦге а11
2.5. Первый запуск: что вы видите?
Когда вы впервые открываете ЮА, вас встречает окно "Ошск 81аЛ". Вот что там
есть:
I-------------------------------------------------------------1
ГОД РЙО - (МДСК 5ТАНТ
I I-----------------------------------------------------------------1 I
[Кем] [бо] [Ргеухоиь] [ОхзазаетЫе]
I Ь------------------------------------------------------------------1 I
1 I
I I-----------------------------------------------------------------1 I
| | КесепС -Шез: ] |
С:\05ег5\,..\ехатр1е.ехе
С:\изег5\...\сгаскте.ехе
[ I_________________________________________________________________I
I
I Г------------------------------------------------------------------1 I
I I Не1р: | |
| | ЮА Ц$ег Магта! | |
| | ЮА КеуЬоагЛ 5Ногсси1$ | |
I 1-----------------------------------------------------------------' I
I________________________________________________________________________।
Что здесь важно:
Ые«у — загрузить новый файл для анализа
6о — открыть файл, с которым вы работали раньше
Весел* ТПез — быстрый доступ к недавним файлам
Пока просто запомните эту картинку. В Главе 4 мы подробно разберём загрузку
файлов.
2.6, Что делать, если что-то пошло не так?
Вот типичные проблемы новичков и их решения:
Проблема 1: "При запуске ЮА вылетает"
Причина: антивирус блокирует ЮА. Временно отключите антивирус или добавьте
ЮА в исключения. Также проверьте, что у вас достаточно прав (запустите от имени
администратора на \ЛЛпйоууз).
Проблема 2: "Нет кнопки ГБ или она не работает"
Причина: у вас ЮА Ргее или вы не установили Нех-Каук ОесотрИег. Решение:
установите ЮА Рго с декомпилятором или используйте 6Ыс1га.
Проблема 3: "ЮА не видит мой файл"
Причина: возможно, файл повреждён или имеет неправильное расширение.
Решение: проверьте, что файл действительно исполняемый. Попробуйте открыть
простой .ехе файл (например, калькулятор Шпроте).
Проблема 4: "Слишком много окон, ничего не понятно"
Решение: закройте все окна, оставьте только три главных — окно функций (слева),
основное окно с кодом (центр), окно вывода (снизу). Всё остальное можно закрыть.
2.7. Ваш первый анализ за 5 минут (превью)
Чтобы вы не заскучали от установки и настроек, вот быстрый пример того, что вы
сможете делать уже через пару глав.
Допустим, у вас есть программа, которая спрашивает пароль. Вы хотите его найти.
Что вы сделаете:
1. Откроете файл в ЮА
2. Нажмёте 5ЫП+Р12 — увидите все строки в программе
3. Найдёте строку "Введите пароль'1 или "Доступ запрещён"
4. Кликнете по ней — ЮА покажет, где она используется
5. Нажмёте Р5 — увидите С-код, где проверяется пароль
6. Прочитаете код и найдёте пароль
Всё! 5 минут, 6 шагов, никакого ассемблера.
I-----------
ПРИМЕР: ПОИСК ПАРОЛЯ
5Й1Н+Е12 * Найти "Доступ запрещён"
I * I
Клик по строке * Прыжок в код
I * I
| Р5 -> Читаем С-код:
I I
| 1-р (5±гстр(1при‘1:, "гесгеМЗЗ") == В) |
I < I
рг1п!ё("Доступ разрешён");
I } I
е1ье
I { I
рг±п^Г("Доступ запрещён”);
I } I
| Пароль: "зеспеТ123“ |
I____________________________________________________________________________!
Это не магия. Это просто работа с правильным инструментом.
2.8. Что дальше?
Теперь, когда ЮА (или 6Ыс1га} установлена и настроена, мы готовы к самому
главному — загрузке файла и анализу кода.
В Главе 3 мы разберём:
Как ЮА обрабатывает разные типы файлов (РЕ, ЕЬЕ, МасЬ-О)
Какие архитектуры поддерживает (х86, АЙМ, М1Р5 и др.)
Как правильно выбрать загрузчик для вашего файла
Итоги главы
ЮА Рго — лучший выбор, но есть бесплатные альтернативы
Для новичка критически важен декомпилятор (Е5) — без него учиться тяжело
Настройте интерфейс под себя (тёмная тема, шрифт, окна)
Основные окна: Еипсбопа, 015а$$етЫу, Ои1ри1, Зйтпдз
Первый анализ займёт 5 минут, если знать правильные клавиши
Готовы загрузить первый файл? Идём дальше!
ГЛАВА 3. Загрузка файла в ЮА
3.1. Что нужно знать перед загрузкой
ЮА мажет анализировать самые разные файлы. Но чтобы анализ прошёл успешно,
важно правильно сказать ЮА, что вы ей даёте.
Представьте, что вы даёте переводчику книгу. Если вы не скажете, на каком языке
она написана, переводчик будет гадать и ошибётся. С ЮА то же самое.
16
I-----------------------------------------------------------------------------1
КАКИЕ ФАЙЛЫ ПОНИМАЕТ ЮА
Платформа Форматы Архитектуры
Ы1пс1сш5 . ехе„ ,(111, .вуз х86, х64
Нпих Е1_Е хВ6, х64, АКМ
<пас05 МасЬ-0 Х64? АВМ64
Апс1Г01с1 . арк, .50 АКИ, ДНМ6А
105 . 1ра, .арр АНН, А8М64
Встраиваемые Прошивки (КАМ) АН1Ч, М1Р5, Н15С-У, РомегРС
В этой книге мы начинаем с самого простого — ЕХЕ-файлов. Это
самый распространённый формат, и для него есть больше всего примеров.
3.2. Как загрузить файл
Загрузка файла начинается с окна "Ошск 51агГ, которое мы видели в Главе 2.
[-------------------------------------------------------------1
ПЕРВЫЙ ШАГ: ЗАГРУЗКА ФАЙЛА
1+ Откройте ЮА
2* В окне 0,и1с1< 51аг1 наймите [Меи]
ИЛИ
1. В главном меню выберите Г Не + Ореп
2, Выберите ваш файл (.ехе, . с!11, . е!Т.
После зтого ЮА покажет диалог за грузки, который мы
разберём в следующем разделе.
33. Диалог загрузки: что выбирать?
Когда вы выбрали файд ЮА показывает диалог с настройками загрузки. Вот как он
выглядит:
ДИАЛОГ ЗАГРУЗКИ ФАЙЛА
-----------------------------------------------------------------------------1
I I
1оас1 ’РгТе: ехатр1е,ехе
I ---------------------------------------------------------------------- I
I I
[х] Сгеа1:е апа1у515 йаТаЬаае (ЮА ыП1 з1:оге апаХузхз 1п-Ро)
[х] Соас! гееоигсез
[х] Ьоас! тшрогТз
[ ] Юас1 йеЬие хп-РогшаИоп (Н ауаНаЫе)
Ргосеззог *уре: [1пте1 8Вх8б ргосеззогз: РЕ} т
I I
. [ОК] [Сапсе1] [не!р]
I I
I____________________________________________________________________________I
Что здесь важно:
СгеаТе апа1у515 даХаЬазе — ЮА создаёт файл лс1Ь (или .164), где хранит результаты
анализа. Это позволяет не анализировать файл заново при каждом открытии.
Всегда оставляйте галочку.
Ьоас! ге5оигсе5 — загружает ресурсы программы (иконки, меню, строки). Это
полезно, потому что в ресурсах часто встречаются подсказки. Оставляйте галочку.
Ьоай 1трог15 — загружает список импортируемых функций (т.е. функций из
системных библиотек). Это помогает ЮА понять, что делает программа. Оставляйте
галочку.
1оа<1 с!еЬид проста 1юп — если у вас есть отладочная информация (файл .рс1Ь)г
ЮА сможет восстановить имена функций. Обычно этого нет, но если есть —
включайте.
Ргосе&5ог Туре — здесь самое сажное' ЮА должна знать, для какого процессора
написан файл. Для \Л/тс1о*л,& ЕХЕ — это "1п1е( 80x86 ргосеккога: РЕ". ЮА обычно
определяет это автоматически. Если не определяет — выберите вручную.
ЗА Что делает ЮА после загрузки
После того как вы нажали ОК, начинается магия. ЮА:
сект
I---------------------------------------------------------------1
ЧТО ДЕЛАЕТ ЮА ПОСЛЕ ЗАГРУЗКИ
X АНАЛИЗИРУЕТ ФАЙЛ
1 | Разбивает файл на секции (Лехб, ..гйата...) | находит точки входа (место, где начинается программа) | Разбирает заголовки ЕХЕ/ЕЬЕ । "1 1 1 1 _|
01 ИЩЕТ ФУНКЦИИ
1 Распознаёт последоеательности команд как функции | Присваивает им имена (5иЬ„401000, 5иЬ_401020г*.) | Показывает их в окне функций । 1 1 1 1 □
С] ПРИМЕНЯЕТ РЦКТ-СИГНАТУРЫ
Г“ [ Сравнивает код с базой известных библиотек | Распознаёт функции из С-рантайма (рг!п1?^ бгетр, гпа11ос) | Переименовывает их (биЬ_401234 + _рг!г|1?П 1 1 1 □
КЁ' ИЩЕТ СТРОКИ
1 | находит все текстовые строки в программе | Сохраняет их в окно 51:г1п^5 (5ЫН+Р12) [ Связывает строки с местами^ где они используются | 1 1 1 1 □
I________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________1
Этот процесс занимает от нескольких секунд до нескольких минут, в зависимости
от размера файла и мощности вашего компьютера.
Во время анализа вы видите в окне вывода что-то вроде:
Дпа1уг1пе 1при1 Н1ея.+
0е*ес1ей х86 РЕ Ше +
ЬоасИпЕ ХгсрогЧз...
РоигИ 234 1трог1ей -Рипс^ХопЯх
Арр1у!п^ РЫ^Т 51^па1иге5.. .
Кесо^п1ге<1 87 Е1апс!агс1 ИЬгагу ^ипс11оп5.
БеагсПхл^ -Рог 51Г1Л^5...
Роиги! 456
Апа1у515 сотр1е1е. 1234 1П5Хгис11опз гесоепХгей,
3.5. Что вы видите после загрузки
После завершения анализа перед вами открывается главное окно ЮА. Оно
выглядит примерно так:
ТекТ
I---------------------------------------------------------------------1
I ЮА РНО - ПОСЛЕ ЗАГРУЗКИ I
---------------------------------------------------------------------I
| ФАЙЛ ПРАВКА ПЕРЕХОД ПОИСК ВИД ОТЛАДКА ПЛАГИНЫ
ФУНКЦИИ ] I код 1 1
1 Лех^: 00401000 РЦ5Й 1 1 еЬр | |
| Л ех1:: 00401001 еЬр, езр
| Лех^:00401003 $иЬ езр, 10Н
_5ХГС1Т1р | ЛехХ: 00401006 ризК о-РТзе! аЕпТегРава
5и6^401020 | Лех! :0040100В са11 _рг1п1Т
5иЬ_401040 - 1 1 1 1
(Нажмите Р5 для С-кода) 1 1 1 1 1 1
вывод
Дпа1уз15 сотрТеТе.
Ргеез Р5 1о «ЗесотрНе.
_
Что важно запомнить:
1. Окно функций слева — здесь список всех функций. Самая важная —
обычно магп или _51аг1. С неё начинается программа.
2. Основное окно с кодом — здесь вы видите ассемблер. Но вы НЕ будете его
читать! Вы нажмёте Е5 и увидите С-код.
3. Окно вывода внизу — здесь ЮА пишет, что она сделала. Полезно для проверки,
всё ли загрузилось правильно.
3.6. Проблемы при загрузке и их решение
Вот что может пойти не так и как это исправить.
Проблема: "ЮА не распознаёт файл"
Причина: Файл повреждён,, или это не исполняемый файл.
Решение: Проверьте файл. Откройте его в Ьех-редакторе
и посмотрите первые байты (М2 для ЕХЕ, ЕЬЕ для Ц.пих).
Проблема: "ЮА выбрала неправильную архитектуру"
Ёех!
Причина: Файл нестандартный, или ЮД ошиблась.
Решение: Вручную выберите архитектуру в диалоге загрузки.
Для Штпйоыз ЕХЕ - "1пТе1 80x86 ргосеззогз: РЕ".
Проблема: "Анализ идёт слишком долго1’
Тех1:
Причина: Большой файл или слабый компьютер.
Решение: Подождите. Или отключите ненужные опции загрузки
(например, Ьоас! гезоигсез, если они нс нужны).
Проблема: "Нет окна функций"
Решение: У1еы Ореп ЗиЬухеыг + ЕипсНопз
Проблема: "Нет кнопки Р5
Причина: У вас ЮА Егее или не установлен Нех-Кауь ОесотрИег,
Решение: используйте ЮА Рго с декомпилятором иди бЫРга.
3.7. Что такое ЮВ-файл и зачем он нужен?
Когда ЮА анализирует файл, она сохраняет результаты в специальный файл:
Для 32-битных файлов — имя_файла. 1РЬ
Для 64-битных файлов — имя_файла. 164
техг
I--------------------------------------------------------------1
ЧТО ТАКОЕ ЮВ-ФАЙЛ?
Исходный .ехе * ЮА анализирует + Сохраняет . 1с1Ь/.1б4
I I
Что хранится в Лс1Ь:
| * Все Функции и их адреса
| • Переименования, которые вы сделали
* Комментарии, которые вы написали
• Типы данных, которые вы задали
• Анализ строк и перекрёстных ссылок
I I
Зачем он нужен:
• Вы можете закрыть ЮА и открыть позже - всё сохранится
• Не нужно анализировать файл заново
• Можно передавать коллегам (вместе с .ехе)
I I
I----------------------------------------------------------------------1
Важно: .НЬ-файл не заменяет исходный ,ехе. Он хранит только результаты анализа.
Если вы удалите .ехе, вы не сможете использовать цс!Ь-
3.8. Практическое задание
Теперь, когда вы знаете, как загружать файлы, давайте сделаем это на практике.
Задание 1. Загрузите простой файл
1. Найдите любой простой .ехефайл на вашем компьютере.
Например, са1с.ехе (калькулятор \Мпс!от). Путь
обычно: С:\К1п(1он5\5у5Тет32\са1с.ехе
2. Откройте его в ЮА (Н1е — Ореп).
3. В диалоге загрузки оставьте все настройки по умолчанию и нажмите ОК.
4. Дождитесь завершения анализа (смотрите в окно вывода).
5, Посмотрите на окно функций. Сколько функций нашла ЮА?
6. Нажмите Р5 (если он есть) и посмотрите на С-код,
Задание 2. Найдите первую строку
1. Нажмите $ГпЛ+Е12 (открыть окно строк).
2. Пролистайте список. Найдите какие-нибудь знакомые строки (например, ’ Еггог",
"ОК", "СапсеГ).
3. Кликните по любой строке дважды. ЮА прыгнет в то место кода, где эта строка
используется.
4. Нажмите Е5 и посмотрите, что делает эта часть программы.
Итоги главы
• Загрузка файла — первый шаг в работе с ЮА
• Правильный выбор архитектуры критически важен
• ЮА автоматически находит функции, строки, библиотеки
• РЬ1 КТ-сигнатуры помогают распознавать стандартные функции
• ЮВ-файл сохраняет результаты анализа для будущей работы
• После загрузки вы готовы к самому главному — анализу кода!
Теперь, когда файл загружен, мы готовы к самому важному — Главе 4, где вы
узнаете о вашей суперсиле: клавише Р5!
3.9. Карта действий: как загрузить файл в ЮА
Вот краткая схема того, что мы сделали в этой главе. Вы можете использовать её
как шпаргалку при первой самостоятельной загрузке.
’Ьек’Ь
КАРТА ДЕЙСТВИЙ: ЗАГРУЗКА ФАЙЛА
ч
ШАГ 1. ОТКРЫТЬ ЮА
ШАГ 2. ВЫБРАТЬ ФАЙЛ
Е11е * Ореп -* выбрать .ехеД е1Т/.с!11
ШАГ 3. ПРОВЕРИТЬ НАСТРОЙКИ В ДИАЛОГЕ ЗАГРУЗКИ
Сгеа1е апа1у$15 йа1аЬа$е
коза ге$оигсез
1оа<1 ХшрогТз
► Ргосеззог Туре: правильно лн определила ЮА?
I
т
ШАГ 4. НАЖАТЬ ОК
I
т
ШАГ 5+ ЖДАТЬ ОКОНЧАНИЯ АНАЛИЗА
Смотреть окно вывода: ''Дпа1у515 сотр1е^ен
I
т
ШАГ 6. ПРОВЕРИТЬл ЧТО ВСЁ ЗАГРУЗИЛОСЬ
► Открылось окно с кодом?
► В окне функций есть функции?
► Р5 работает?
ГОТОВО! Можно переходить к Главе 4 (Е5 - ваша суперсила)
I I
I_________________________________________________________________________________I
ГЛАВА 4. Р5 — ваша суперсила (декомпиляция)
4.1, Что такое декомпиляция и зачем она нужна
Вы уже знаете, что ЮА — это дизассемблер. Она переводит машинный код в
ассемблер. Но ассемблер — это всё равно сложно для новичка. Слишком много
деталей, слишком много команд, слишком легко запутаться.
Декомпиляция решает эту проблему. Она переводит ассемблер в С-подобный
код. Вместо того чтобы читать шоу, ризн, сан и гадать, что происходит, вы
читаете ю, Гог, втгстр и сразу понимаете логику.
ЧТО ДЕЛАЕТ Е5
------------------------------------------------------------------------1
I
МАШИННЫЙ КОД |
(байты> которые выполняет процессор)
ЕР 15 30 40 00 00 |
I I
АССЕМБЛЕР (читает ГСА) |
с а 11 Цыогй рТг [403630Н] |
том еах, [еЬр+8]
ривЬ еах
I |
Г5 (ДЕКОМПИЛЯЦИЯ) |
1 |
С-ПСЕВДОКОД (читаете ВЫ) |
пеанК = рг1пх;р(1при"С);
Ключевой момент: Нажатие Р5 — это не "волшебная кнопка", которая даёт
настоящий исходный код. Это псевдокод — очень похоже на С, но с некоторыми
особенностями. Он создан для чтения, а не для компиляции. Но для новичка он в
10 раз понятнее ассемблера.
4.2. Ассемблер уб С-псевдокод: сравнение
Давайте посмотрим на реальный пример. Вот код, который проверяет пароль:
АССЕМБЛЕР (то, что вы видите до нажатия Е5):
Лех1:00401000 РЫбИ еЬр
.16X1:00401001 поу еЬр, езр
.16X1:00401003 $иЬ е&р, 10Н
.16x1:00401006 тоу еах, [еЬр+8]
.16X1:00401009 ризЬ еах
.16x1:0040100А С311 _51:г1ея
. 1ех1:0040100Р асОД езр, 4
,16X1:00401012 стр еах, 5
.16X1:00401015 аИогТ 1ос_401040
.16X1:00401017 рИБИ аБесгеТ
,1ех1:0040101С [еЬр-ьЗ]
.1ех1:0040101Е са11 _51гстр
.16x1:00401024 аск! езр, в
Лех!: 00401027 еах, еах
Лех1:00401029 ЗП2 бНог! 1ос_401040
Лех!: 0640102В ШОУ еах? 1
Лех!: 00401030 Зтр ьЬогХ 1ос_401045
Лех*: 00401032 10 с_ 401040:
ЛехГ: 00401О32 хог еах, еах
Л ех1:: 00401045 1ос_ 401045:
Лех1:00401045 ШОУ езр, еЬр
Лех1:00401047 рор еЬр
Лех!; 00401048 ге!п
С-ПСЕВДОКОД (то, что вы видите после Е5):
С
В001 СНескРа5^огб(соп51: сТ1аг* хгзри!:} {
Н (ъ1г!еп(1при11} == Б) {
(51гспф(1пр1гЦ Чесге^1') == 0) {
гегигп ТИКЕ;
}
)
геТигп ЕАЬБЕ;
}
Разница очевидна. В ассемблере — 20 строчек и нужно знать, что
такое еЪр, е&р, теат, Зпг. В ^псевдокоде — 7 строчек на понятном языке.
4.3. Как читать псевдокод (и не запутаться)
Псевдокод выглядит как С, но у него есть свои особенности. Вот основные правила:
Особенность 1: Странные имена переменных
Вместо нормальных имён вы увидите у1, у2, уЭ или ах, а2, аз.
с
1П1 __сс1ес1 5иЬ_401000(1пТ а1; 1п1: а2) {
1пТ уЗ; // что эпю?
уЗ = а1 + а2,
геТигп уЗ;
Что делать: Переименуйте их! Нажмите на а1 -> нажмите ы -»
введите х или 1прит: или з1ге. Сделайте код читаемым.
Особенность 2: Неоптимальные конструкции
Декомпилятор не всегда генерирует красивый код. Он может создать странные
циклы или лишние переменные.
с
// Декомпилятор может выдать такое;
нЫ1е ( 1 ) {
1-Е { сопдШоп! ) Ьгеак;
1* ( сопдИ1оп2 } сопт1пие;
// ...
// Хотя логически это:
и№1е ( сопдтМоп! && сопд1Т1оп2 ) {
// ...
}
Что делать: Не пугайтесь. Просто поймите логику, а не красоту кода.
Особенность 3: Приведение типов
Декомпилятор часто использует приведение типов (1п1), (сНаг ♦), (вуте *).
*(_ВУТЕ ')(а1 + уЗ) = *{_ВУТЕ *)(32 + у4);
Это просто копирование байта из одного места в другое. Можно переписать как:
ЬиЕЕег[1} 5оигсе[^];
Что делать: Просто читайте как есть. Или переименуйте переменные, чтобы стало
понятнее.
4.4. Странные переменные (у1, у2, уЗ) — что это?
Это локальные переменные. В ассемблере они хранятся на стеке. Декомпилятор не
Знает, как их назвать, поэтому даёт имена VI, у2, уз и так далее.
Тех!
ЧТО ТАКОЕ у2, уЗ?
В ассемблере:
<ПОУ
[еЬр-4], О
; это VI
шоу [еЬр-8], 10 ; это VI
шоу [еЬр-ЭСК]20 ; это уЗ
1---------------------------------------------------------------1 I
I
В псевдокоде:
| Ш у1 = 0; 1 // счётчик
1п^ у2 = 10; // максимальный размер
1Л1 уЗ = 20; // что-то ещё Г
Что делать:
1, Посмотрите, как используется переменная
2* Догадайтесь? что она означает
3* Нажмите 1ч и переименуйте
4+ VI + соип^ег, у2 + тах_51ге, уЗ * гебиИ
4.5. Когда Е5 врёт (и что делать)
Декомпилятор — это программа, а программы иногда ошибаются. Вот типичные
случаи, когда Е5 выдаёт не совсем то, что есть на самом деле.
Случай 1: Неправильное определение типа
Декомпилятор может подумать, что указатель — это число, или наоборот.
// Г5 показывает:
1п1 уЗ = 31 +• 4;
// Д на самом деле это:
сКаг* рТг = (сНаг#)а1 + 4;
Решение: Нажмите на а1, нажмите V и задайте правильный тип.
Случай 2: Пропущенные структуры
Если программа использует структуру, декомпилятор может не распознать её.
с
// Р5 показывает:
*(_ОЫОКО *)(а1 + 8) = 10;
*(_ОЫОКО *)(а1 + 12) = 20;
// 4 на самая -Йеле это:
51гис1 Ро1г1 {
1п^ х;
1П1 у;
};
Ро1п1:* р = (Ро1п^#)а1;
р->х = 10;
р->у = 20;
Решение: Создайте структуру (ХЛеуу -» Ореп БиЬмешз — коса! Турез) и примените её
к переменной.
Случай 3: Оптимизация компилятора
Компиляторы часто оптимизируют код, и декомпилятор не может восстановить
оригинальную логику,
с
// Р5 показывает странный над:
ыННе ( VI < ) {
И ( !*(_ВУТЕ *)(уЗ + VI) ) Ьгеак;
У1++;
}
// Логически это просто:
мН Не ( Ьи^ег[у1] != ' \0' ) {
У1++;
}
Решение: Поймите логику, переименуйте переменные, добавьте комментарий,
4.6. Что делать, если Р5 не работает
Бывает, что вы нажимаете Е5, а ничего не происходит. Вот причины и решения:
Причина 1: У вас ЮА Егее
ЮА Егее не имеет декомпилятора. Решение: используйте ЮА Рго или СЫска.
Причина 2: Вы не установили Нех-Науз ОесотрПег
При установке ЮА вы могли пропустить компонент. Решение: переустановите ЮА
и выберите "Нех-Рауз □есотрИег".
Причина 3: Файл повреждён или имеет нестандартный формат
Декомпилятор работает не со всеми файлами. Решение: попробуйте другой файл
Причина 4: Вы находитесь в неправильном режиме
Иногда ЮА показывает не код, а данные (Ьех-дамп). Решение: нажмите С, чтобы
переключиться на код.
4.7. Практика: найдите пароль за 2 минуты
Теперь давайте применим всё, что мы узнали, на практике.
Задание: У вас есть программа, которая спрашивает пароль. Найдите его.
Шаг 1. Загрузите файл в ЮА (как в Главе 3)
Шаг 2. Нажмите 5ЫЙ+Н2 (открыть окно строк)
Найдите строки, связанные с паролем:
1 1 | ОКНО СТРОК (5НТЕТ+Е12) | 1 1
1 1 дййгеаз 1 иепегь Туре 5Тг1пе 1 1
1 | 00403000 14 А5С11 "Введите пароль: 11 1
1 00403020 18 А5СИ "Доступ разрешён’" 1
1 00403040 19 А5С11 “Доступ запрещён!4 1
| 00403060 1 1 7 А5С11 "зесгеГ' | «- ВОТ ОН! 1 1
Шаг 3. Кликните по строке "весгеГ дважды
ЮА прыгнет в то место, где эта строка используется.
Шаг 4. Нажмите Р5
Вы увидите С-псевдокод;
с
В001 СЬескРэ55ногс1(соп51 1про^) {
И (^гстр(1приТ, ’^есгеТ") == 0} {
ге1игп ТИПЕ;
}
геТигп ЕАЬБЕ;
Шаг 5. Прочитайте пароль
Он Прямо В коде: "зесгеГ’.
Всё! 2 минуты, 4 нажатия клавиш, никакого ассемблера.
4.8. Карта действий: поиск пароля через Е5
Вот краткая схема того, что мы сделали. Используйте её как шпаргалку.
Гехт
—
КАРТА ДЕЙСТВИЙ: ПОИСК ПАРОЛЯ ЧЕРЕЗ Е5 1 2 * * * 6 7
1. ОТКРЫТЬ ФАЙЛ В ЮА -» Глава 3
I
V
2. НАЖАТЬ 5Н1ЕТ+Е12 + Открыть окно строк
I
т
3™ НАЙТИ СТРОКУ + "Доступ запрещён" / "Ошибка"
"Введите пароль11 / "Виссе^з"
I
▼
4+ КЛИКНУТЬ ПО СТРОКЕ + ЮА прыгнет б КОД
ДВАЖДЫ
Бя. НАЖАТЬ Е5 + Ассемблер + С-псевдокод
I
т
6. НАЙТИ В КОДЕ -* 1Т (аСгетр (±при1 , "^естеТ")-^) |
СРАВНЕНИЕ
7. ПРОЧИТАТЬ ПАРОЛЬ -» ГОТОВО!
Е_ Клавиши: 5И1Т1+Е12 + клик -» Е5 + готово!!
3 Время: 2-3 минуты
эЛ Совет: Если пароль не виден? ищите сравнение (з1гстрэ
шелюпр, или просто ==)*
Итоги главы
Р5 — самая важная клавиша в ЮА, Она превращает ассемблер в С-псевдокод.
Псевдокод — это не настоящий код, но он очень похож на С.
Странные переменные (у1, у2) — это локальные переменные. Переименуйте их!
Р5 иногда ошибается. Перепроверяйте логику.
Поиск пароля через Е5 занимает 2-3 минуты,
Готовы к навигации по коду? Идём дальше!
ГЛАВА 5. Навигация по коду — как не заблудиться
5.1. Проблема навигации
Когда вы открываете программу в ЮА, перед вами — тысячи, а иногда и сотни
тысяч строк кода. Это как оказаться в незнакомом городе без карты. Вы видите
улицы (инструкции), дома (функции), но не понимаете, где находитесь и куда идти.
В этой главе мы научимся ориентироваться. Вы узнаете, как находить главные
функции, как перемещаться по коду, как понять, кто кого вызывает, и как не
потеряться в лабиринте.
1 1 | ПРОБЛЕМА НАВИГАЦИИ |
Вы видите: 1 1
1 1 1 .19X1:08401000 рС1БН еЬр | |
1 1 .19X1:00401001 ШОУ еЬр, е$р
1 1 .19X1:00401003 са!1 5иЬ_401100 | |
1 1 .19X1:00401008 1Й31 еах, еах
1 1 Лех1:0040100А ЗЛ2 1ос_401206 | |
1 1 .19X1=00401010 Ф-Г-Раег аЕггог
1 1 ,19X1:00401015 сан _рГ1П«-Г
I 1-------------------------------------------------------------------1 I
I I
Вопросы новичка:
? Где начало программы?
? Куда ведёт этот «11?
? Что будет, если сработает Дпг?
? Как вернуться туда, откуда пришёл?
I I
__
5.2. Окно функций — ваша карта города
Самое важное окно для навигации — Еипс11оп5 УУтйоуу (окно функций). Это как
карта города, где каждая функция — это район.
1 1 | ОКНО ФУНКЦИЙ (Е11МСТ1ОМ5 И1ЫООЫ) |
1 , 1
1 1 1 1 1 РипсПопз 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 Л е х’Ь: 00401000 Лех1:00401050 Лех^: 00401100 Лех1:00401200 Лех1:00401300 лехг: 00401350 ЛехЛ: 00401400 Лех^:0Э401500 _та1п СНескРаззуогс! УаНЦаТеТприТ _рг1п‘Ы: „з^гопр ЗиЬ.401400 зиЬ_40150® 1 1 * ТОЧКА ВХОДА | | Ч- ГЛАВНАЯ ФУНКЦИЯ ч- ВАША ЦЕЛЬ | | 1 1 * СТАНДАРТНАЯ ФУНКЦИЯ | | * НЕИЗВЕСТНАЯ ФУНКЦИЯ | | 1 1 1 1 ! 1
| Как Гор * открыть: Ухем ячая клавиша: ( -» Ореп 5иЬу1е^Б Лг1+Р 1 1 * Еипс1:1оп5 1 1 1
Что важно в окне функций:
1. Имена — ЮА даёт имена функциям. _тахп — это главная функция. _рг1п1^ —
стандартная функция. аиЬ_401000 — функция, которую ЮА не распознала.
2. Цвета — ЮА подсвечивает разные типы функций:
о □ Зелёные — функции, которые ЮА уверенно распознала
о □ Жёлтые — предположительные функции
о О Белые — стандартные библиотечные функции
3. Сортировка — кликните по заголовку, чтобы отсортировать по имени, адресу или
размеру.
5.3. Где начало? Точки входа (ЕпТгу ₽О1П15)
Когда, программа запускается, она начинает выполнение не с та1п(), а с точки
входа (епГгу рот!). Это стартовый код, который настраивает окружение, а потом
вызывает ша1п().
I--------------------------------------------------------------------------------------------
ТОЧКИ ВХОДА (ЕЛ1ТЯУ РО11ЧТ5)
Как найти: Зитр ч Зитр еп!гу ро!п1
Горячая клавиша: С1г1+Е
ЕпГгу Р011Ч5
.Гех!:00401000 <- Начало выполнения
ЩпМахп Лех1:00401500 *- Окно
ОПМахп Аех1:00402000 * Для 01_1_
Что важно:
- 'ггагГ - это самая первая функция, которую выполняет
процессор* но она делает много системных вещей.
- 'гса1п' или чЫ1пМа1п’ - это ваша цель* Здесь начинается
логика, которую написал программист.
- Для консольных программ ищите ь_мэ1гГ.
- Для Ыхпйоыа- приложений ищите 'ЫхпМайГ или ьшШ1пМэ1п' .
Совет новичку: Не начинайте анализ с втагт. Там много служебного кода. Сразу
идите в _гпа1п или ШхпМатп.
5.4. Перекрёстные ссылки (X) — кто кого вызывает
Это самый мощный инструмент навигации. Перекрёстные ссылки показывают,
где используется функция и кто её вызывает.
Ьех!
1 | ПЕРЕКРЁСТНЫЕ ССЫЛКИ (X) —1 1
Вы находитесь на Функции СИескРа$5^огй: Лех1:00401100 СНескРа55.шогс1: 1ех1:00401100 ризИ еЬр .16X1:00401101 мои еЬр, езр | .16X1:00401103 ... Вы нажимаете х (на клавиатуре) 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 Г 1 Хге+5 1о СНескРа$5иогс1 1 [ Ргот .Тех!=00401050 са11 СКескРаззыогй «- ВЫЗЫВАЕТ [ ! Ггот .Тех! = 00401200 са11 СИескРаззыогс! < ВЫЗЫВАЕТ | Ггот . 1ех1: = 00401500 шоу еах, □ТТзе’Г СКескРавзногй ।
Что вы узнаёте: Где используется функции Кто вызывает её из другой части программы Какой адрес вызывает Как перейти к вызывающему коду: Дважды кликните по строке е окне Хге-^5 1
Когда использовать X:
• Вы нашли интересную функцию и хотите узнать, где она вызывается
• Вы ищете, откуда приходит значение в переменную
• Вы хотите понять, какой код выполняется перед функцией
• Вы хотите проследить поток выполнения программы
5.5, Графы переходов — визуальная навигация
Иногда читать код построчно утомительно. ЮА может показать его в виде графа —
схематичной карты, где видны все переходы.
I----------------------------------------------------
ГРАФ ПЕРЕХОДОВ (СКАРН 71Е«)
Нажмите ПРОБЕЛ, чтобы переключиться между текстовым и
графическим режимом..
I-------------------
ризИ еЬр
са!1 _5Тг1еп
стр еах, 5
|------------1 I-------------1
Лпз | | з^гстр
(ошибка) | | зесгеТ
I____________I I_____________I
т г
г----------1 г---------1
| ТИПЕ | | ЕАЬЗЕ |
I__________I I_________I
Зелёные стрелки = безусловные переходы (Зтр)
Красные стрелки = условные переходы 32л Ле)
Синие стрелки = вызовы функций (са11)
Когда полезен граф:
• Вы хотите быстро увидеть структуру функции
Нужно понять, сколько ветвлений (|(/е1$е) в коде
Вы ищете, куда ведёт конкретный переход
Вы хотите увидеть циклы (они выглядят как замкнутые петли)
5.6. Навигация по адресам и прыжки
Иногда вам нужно перейти к конкретному адресу. Вот как это сделать:
сект
---------------------------------------------------------
НАВИГАЦИЯ ПО АДРЕСАМ
Переход к адресу:
Зитр * Титр То аЦ^геьа (или просто нажмите б)
Зитр (о аййгезг
Айс1ге55: [0x00401000 ]
II II
| | [ОК] [Сапсе1] | |
I 1------------------------------------------------------------1 I
I I
Что можно ввести:
• 0x401090 - шестнадцатеричный адрес
• 401000 - без префикса
* _1па1п - имя функции (ЮА найдёт сама)
• та!л+10 - смещение от функции
I I
I____________________________________________________________________I
Навигация назад и вперёд:
Ебс — вернуться назад (как Васк в браузере)
С1г1+Еп<ег— перейти вперёд (как Еопл/агс! в браузере)
Это самые полезные клавиши! Вы часто будете прыгать по коду и потом
возвращаться.
5.7. Ключевые горячие клавиши для навигации
Вот ваш минимальный набор:
ПРОБЕЛ
КЛЮЧЕВЫЕ КЛАВШИ ДЛЯ НАВИГАЦИИ
- + Перейти к адресу
- + Показать перекрёстные ссылки (кто вызывает)
* Переключить режим (текст / граф)
+ Вернуться назад
С1г1+Еп1ег + Перейти, вперёд
С1Г1+Е
С1г1+Е
ДИ+Мр
АЦ+Ромп
+ Найти в окне функций
- * Показать точки входа
- + Перейти к предыдущей функции
- > Перейти к следующей функции
5.8. Практика: проследите путь выполнения программы
Теперь давайте применим всё на практике.
Задание: У вас есть программа, которая выводит сообщение. Проследите путь
выполнения от начала до конца.
Шаг 1. Найдите точку входа
Нажмите стг1+е — увидите список точек входа. Найдите _ша1п или Н1пма1п. Кликните
по ней.
Шаг 2. Изучите функцию
Теперь вы видите код та1п. Нажмите пробел, чтобы увидеть граф. Посмотрите,
какие вызовы (с а И) есть в функции.
Шаг 3. Перейдите по вызову
Найдите в коде вызов са11 зиЬ-Даива. Нажмите на него и нажмите ЕпТег (или
дважды кликните). ЮА перейдёт к этой функции.
Шаг 4. Вернитесь назад
Нажмите Евс, чтобы вернуться к _ша1п.
Шаг 5. Узнайте, кто вызывает функцию
Найдите 2иЬ_401100. Нажмите х. Увидите список вызовов. Изучите, кто и откуда
вызывает эту функцию.
Шаг 6. Найдите строки и проследите путь
Нажмите 5Н 1-РТц-Р 12, найдите строку "Не11о, \Л/ог1д!“ или похожую. Кликните по ней.
ЮА прыгнет в код. Проследите, как программа доходит до этой строки.
5.9. Карта действий: навигация по коду
Вот краткая схема навигации:
КАРТА ДЕЙСТВИЙ: НАВИГАЦИЯ ПО КОДУ
1, ОТКРЫТЬ ФАЙЛ В ЮА -* Глава Э
2* т НАЖАТЬ СТКЬ+Е + Найти точки входа
3. т ВЫБРАТЬ _МА1П ИЛИ М1ПМ31П -* Перейти к главной функции
4. ▼ ИЗУЧИТЬ ФУНКЦИЮ (общий обзор) -* -+ Нажать ПРОБЕЛ для графа Найти вызовы (са!1)
5* т ПЕРЕЙТИ ПО ВЫЗОВУ + Нажать ЕпТег на вызове
6 + т ИЗУЧИТЬ НОВУЮ ФУНКЦИЮ -э Прочитать код Нажать Р5 для С-псевдокода
7. т НАЖАТЬ Е5С Вернуться назад
8* т НАЖАТЬ X НА ФУНКЦИИ (перекрёстные ссылки) + Узнать., кто её вызывает
Ключевые клавиши: С1г1+Е + ПРОБЕЛ * Еп1:ег + Е5 + Езс + X
Совет: Не бойтесь прыгать по коду* Ебс всегда вернёт вас.
I I
I____________________________________________________________I
Итоги главы
• Окно функций — ваша карта. Ищите _та1п или Шпиагп..
• СЫ + Е — показывает все точки входа программы,
• X — показывает перекрёстные ссылки (кто вызывает функцию).
• ПРОБЕЛ — переключает между текстовым и графическим режимом.
* б — прыжок к адресу или имени функции,
• Еяс — возврат назад (самая полезная клавиша?).
• Граф переходов — помогает визуально понять логику функции.
Теперь, когда вы умеете ориентироваться в коде, мы готовы к самому
быстрому способу анализа — поиску по строкам!
ГЛАВА 6. Работа со строками (5ИИ1+Р12)
6.1. Почему строки — это золотая жила
Представьте, что вы ищете клад. У вас есть карта, но на ней нет пометок. Вы
блуждаете, пробуете одно место за другим — и теряете время.
Теперь представьте, что на карте есть яркие флажки, которые показывают: "ЗДЕСЬ
КЛАД!". Именно так работают строки в программах.
!------------------------------------------------------------1
ПОЧЕМУ СТРОКИ ВАЖНЫ
Программисты ОСТАВЛЯЮТ строки для пользователей:
"Введите пароль"
"Доступ разрешён"
"Ошибка: неверный логин11
"Приветл мир!"
Эти строки - ваши малки. Они ведут прямо к логике программы:
"Введите пароль"
программа ждёт ввод
‘'Доступ разрешён" + проверка прошла успешно
"Доступ запрещён" проверка не прошла
I I
Если вы найдёте "Доступ запрещён", вы в двух шагах от
проверки пароля!
I I
_____________________________________________________________________________I
Запомните: В 90% случаев анализ начинается со строк. Это самый быстрый путь к
цели.
6.2. Открываем окно строк
Окно строк — это список всех текстовых строк, которые ЮА нашла в программе.
се кт
1 1 | ОКНО СТРОК (5Н1РТ+Г12) |
1 ъ 1
1 5-Ьг±п^5 [ 1 1 1 1 1 1 1
1 1 АсИге^ | | 00403300 | | 03403020 | | 00403040 | | 00403060 | | 00403070 | | 00403390 | | 004030Д0 1 1 1еп^1:К 14 1Я 19 7 12 3 6 Туре АБСИ АБС II дзен АБС II ДБС11 А5С11 АБС 11 - - - - . 1 1 5Тг1пе | | 'Введите пароль: " "Доступ разрешён Г* "Доступ запрещён!'" "йесге!11 "НеПо^ Ыог1сП1Г "Еггог: ад" | | ,|аскп1п" | 1 1 1 1
Как открыть: | ИЛИ: 71еи 1— । 1 : 5Ы-РТ+Р12 | Орел 5иЬу1ен5 + 51г1пе5 1 -1
Что вы видите в окне строк:
• АсИгекя — адрес, где строка хранится в памяти
• ЬепдСК — длина строки (в байтах)
• Туре — тип строки (А$С11, и пкоде, 1ЯР-8)
• 5Тппд — сама строка (читаемый текст}
Важно: Если вы видите странные символы вместо текста — значит, строка
закодирована (Опкоде или что-то другое). Об этом мы поговорим позже,
6.3. Поиск строк
В окне строк есть поиск. Это ваш главный инструмент.
1ех1:
I-------------------------------------------------------------1
ПОИСК В ОКНЕ СТРОК
Способ 1: Встроенный поиск в окне строк
1. Откройте окно строк ($Н1₽1:+Р12)
2. Нажмите С1г1+Е
3. Введите слово для поиска
4». Нажмите Еп^ег
Например, введите "пароль11 и ГОД покажет все строки с
этим словом*
Способ 2: Глобальный поиск
1- Нажмите А1Л+Т
2. Введите слово для поиска
3, Выберите область поиска (вся программа)
4., Нажмите ОК
Альтернатива: ^еагсЬ -* ТёхЪ,в*
Что искать в первую очередь:
Что искать
Где искать
Почему
пароль", "раззмогсГ, "разз"
Окно строк
Прямой путь к проверке паро?
доступ", “ассезз", "дгапГед", "бепес!" Окно строк Показывает результаты провер
Что искать
Где искать Почему
"ошибка", "еггог", ТаН" Окно строк Место, куда программа попади
"зиссезз", "ок” "уаНд” Окно строк Место, куда программа попади
"адтю", Тоо1", "изег" Окно строк Возможные логины или роли
6.4. От строки к коду (двойной клик)
Это самый важный шаг. Когда вы нашли нужную строку, вы можете перейти в код,
где она используется.
1ех1
ОТ СТРОКИ К КОДУ (ПОШАГОВО) 1
ШАГ 1. Бы нашли строку "Доступ запрещён" 1 1
ШАГ т 2. Кликните дважды по строке в окне 1 $ТГ1ПЁ5 1
ШАГ V 3. ЮА прыгает в код, где эта строка 1 1 используется 1
ШАГ т 4. Бы видите что-то вроде: 1 1 1
Лёх!: 00401040 ризИ о-^-Ве! аДссе5 50ёп1ёс1 ВОТ ЗДЕСЬ
.16x1:00401045 сб11 =рг1п1-Е
ШАГ 5. Посмотрите на код ПЕРЕД этим местом
Ищите условные переходы (Зпг^. ^е) или сравнения
.16X1:00401020 са11 СИескРазБЫОГс!
.1ех1:00401025 1е51 еах, еах
1ех!:00401027 1ос_5иссе55 *- Если ТКУЕ
,16X1:00401020 ри&Н о1Т^е! аДссеЕаОепхес!
ШАГ 6. Нажмите Е5 - увидите С-псевдокод
1-Е (СКескРаззыогчЦ хпри!)) {
рг1п1Е("Доступ разрешён");
} е1?е {
рг1п^( "Доступ запрещён");
}
6.5. Типы строк: А5СП, Опкоде, 1ЛР-8
Иногда вы видите странные символы вместо текста. Это потому, что строка
закодирована в другом формате.
I-------------------------------------------------------------------------------1
I ТИПЫ СТРОК I
А5С11 (обычный текст)
48 65 6С 6С 6Е -> "Не11о"
Каждый символ = 1 байт
Русские буквы не поддерживаются (будут кракозябры)
ОМЮТЕ (ОТЕ-16)
48 00 65 00 6С 00 6С 00 6Е 00 - "НеПо"
Каждый символ = 2 байта
Поддерживает любые языки
В ЮА отображается как 1ШС00Е
иТЕ-8
Привет (русские буквы)
Каждый символ = 1-4 байта
в ЮА отображается как 11ТЕ-8
КАК ОПРЕДЕЛИТЬ:
В окне есть колонка Туре
• Если видите "АБСП1” + обычный текст
• Если видите '1ШС00Е ' + кликните по строке, ЮА покажет
правильный текст
• Если видите краказ-ябры -+ попробуйте поменять кодировку
(0р^1оп5 -+ АБСII ^г1п^ 5^у1е)
Совет: Если вы видите странные символы, попробуйте кликнуть по строке в окне
ЗГппдз, Иногда ЮА показывает правильный текст только при выборе,
6.6. Поиск по строкам без окна строк (А1Г+Т)
Иногда удобнее искать не в окне строк, а по всей программе.
сект
1 ГЛОБАЛЬНЫЙ ПОИСК (АЬТ+Т) 1 1
1. Нажмите А1Л+Т 1 1 1
2, Введите текст для поиска: 1 1
1 1 1 1 1 1 1 ЬеагсЬ Тех*: Б1:г1п^: [раззшогй Сазе 5епз1Муе: [ ] Ы1ю1е шогс!з: [ ] 1 1 1 1 ] 1 1 1 1 1 1 1
3. нажмите ОК 1 1 1
4. ЮА покажет результаты: 1 1
1 1 1 1 1 1 1 БеагсН гезиИгз: 09403'000 "Еп1ег раззиогс!: 11 00401100 тоу [еЬр+8], о-Е+зе! аРаззыогй 00401200 риз*1 о-ЕГзе! аРаззмогй | 1 1 1 1 1 1 1 1 1 1 1
и. 1 —3
Когда использовать А11+Т вместо 5ЫН+Г12:
Вы ищете не просто строку, а её использование в коде
Строка может быть не в списке строк (например, сгенерирована динамически)
Вы хотите найти все упоминания слова, а не только строки
6.7. Фильтры в окне строк
В больших программах строк может быть тысячи. Фильтры помогут сузить поиск.
гехг
Г-------------------------------------------------------------------
ФИЛЬТРЫ В ОКНЕ СТРОК
Внизу окна строк есть поле для фильтра:
51:г1пе5 [РШег: раза] |
00403000 "Введите пароль: " *- ВИДНО
00403060 "зесгеЪн *- видно
00403020 14 До с туп разрешён!1" СКРЫТО
00403040 "Доступ запрещён!1" + СКРЫТО
Как работает:
ЮА показывает только строки, содержащие введённый текст.
Это мгновенно сужает поиск,
Примеры фильтров:
• ира55'' -> покажет все строки со словом разь
• "’еггог" покажет асе строки об ошибках
• ’ЪИ^р11 + покажет все ККЬ
* Р|с1еЬи8!| + покажет отладочные строки
6.8. Практика: найдите все важные строки
Теперь давайте применим всё на практике.
Задание 1. Найдите проверку пароля
1. Откройте файл в ЮА
2. Нажмите 5ЫГ1+Р12
3. Введите в фильтр "пароль" или “раззад/огсГ
4. Найдите строку, связанную с вводом пароля
5. Кликните по ней дважды
6. Нажмите Р5 —увидите проверку пароля
Задание 2. Найдите сообщения об ошибках
1. Нажмите 5ЫЙ:+Р12
2, Введите в фильтр "ошибк" или "еггоГ
3. Найдите строку об ошибке
4. Кликните по ней дважды
5. Посмотрите код ПЕРЕД этой строкой
6. Найдите условие, которое ведёт к ошибке
Задание 3. Найдите "секретные" строки
Иногда программисты оставляют строки, которые не видны пользователю:
• "зесгеГ*
• "ас1т1п"
• "12345”
• "йеЬий”
1. Нажмите 5ЫЙ+Р12
2. Введите в фильтр "зесгеГ или "адш1п"
3. Посмотрите, что нашлось
4. Перейдите к коду и нажмите Р5
6.9. Карта действий: работа со строками
I------------------------------------------------------------1
КАРТА ДЕЙСТВИЙ: РАБОТА СО СТРОКАМИ * I 2
1. ОТКРЫТЬ ФАЙЛ В ЮА + Глава 3
I
т
2 + НАЖАТЬ 5Н1РТ+Р12 -+ Открыть окно строк
т
3- ИСПОЛЬЗОВАТЬ ФИЛЬТР *+ Введите ключевое слово
(внизу окна строк) "пароль”, 11 еггог”, "зесге!1"
4» КЛИКНУТЬ ПО СТРОКЕ * Дважды кликнуть по интересующей |
ДВАЖДЫ + строке |
I
т
5. ЮА ПРЫГАЕТ В КОД » Вы видите ассемблер
I
▼
6. ПОСМОТРЕТЬ ВВЕРХ + Найдите условные переходы
(на 5-10 строк) -» ^е) или сравнения
I
т
7. НАЖАТЬ Е5 * Прочитать С-псевдокод
I
▼
8. найти логику -> ,Г1Т ($-сгс1пр(1пр|Л, ,,$есгеГ,)==0)"
Е23 Клавиши: 5ЫЕ1:+Е12 -» С1г1+Е * клик -» Е5
Совет: Строки - ваш главный маяк. Начинайте анализ с них!
И Время: 1-3 минуты
I_________________________________________________________________
6.10. Альтернативный подход: если строк нет
Иногда строки отсутствуют. Это может быть потому что:
1. Программа обфусцирована — строки зашифрованы
2. Строки сгенерированы динамически — создаются во время работы
3. Программа упакована — сжата или зашифрована
Что делать:
Ъех!
I-----------------------------------------------------------------
| ЕСЛИ СТРОК НЕТ |
I----------------------------------------------------------------1
I I
Если в окне строк пусто или только кракозябры:
I I
1. Проверьтел не упакоеанз ли программа
-* Смотрите на импорты: есть ли 11РХ, ТПетЫа, УМРго^&с!:?
Если да,, нужно распаковать (Глава 16)
2. Используйте Д11+Т для поиска по байтам
-* Поиск по байтам; ЗеагсИ -» Зечиепсе о-Р ЬуТеа...
-» Введите последовательность байтов
3- Используйте динамический анализ (отладка)
-» Запустите программу и посмотрите строки в реальном времени|
-» Глава 10-11 (отладка)
4. Используйте плагин для поиска строк
+ Например, Е1пс1Сгур1 или 51г1п^5еагсЬег
Итоги главы
Строки — самый быстрый способ анализа. Начинайте с них.
5ЫП+Е12 — открывает окно всех строк в программе.
Фильтр в окне строк — мгновенно сужает поиск.
Двойной клик по строке — переносит в код, где она используется,
Е5 после перехода — показывает С-псевдо код проверки.
Типы строк —А5СН, Огнсос1е, 11ТЕ-8. Если видите кракоэябры — проверьте
кодировку.
Если строк нет— возможно, программа упакована или обфусцирована.
Теперь вы умеете находить строки и переходить к коду. В следующей главе
мы научимся делать код читаемым — переименовывать функции и
добавлять комментарии!
ГЛАВА 7. Переименование и комментарии — делаем
код читаемым
7.1. Почему код в ЮА такой нечитаемый?
Когда ЮА анализирует программу, она не знает, как программист называл свои
функции и переменные. Поэтому она даёт им автоматические имена:
Функции: 5иЬ_401000, ьиЬ_401020, зиЬ_401100...
Переменные: VI, у2, «3, а1, а2...
Метки: юс.дезезе, юс.двюве...
Это как если бы вы читали книгу, где все имена заменены на "Персонаж !"
‘Персонаж_2"г "Место_1". Понять сюжет можно, нетяжело.
ЧТО ВИДИТ НОВИЧОК ПОСЛЕ ЗАГРУЗКИ
До переименования
1п1___сйес! 5иЬ_4О1000(1гт1: а1, 1п1 а2)
{
1п1 уЗ;
1п1 у4;
уЗ • а1 + 10;
у4 = зиЬ_401100(уЗ);
н ( У4 == а2 )
ге^игп аиЬ_401200(у4);
ге!игп 0;
Вопросы:
? Что такое а1 и а2?
? Что делает ьиЬ_401100?
? Что делает 5иЬ_4012Й0?
? Что возвращает функция?
НИЧЕГО НЕ ПОНЯТНО!
Решение: Переименовать всё! Дать понятные имена функциям, переменным и
меткам.
7.2. Как переименовать функцию (М)
Это самое важное действие. Вы находите функцию, понимаете, что она делает, и
даёте ей осмысленное имя.
Тех!
КАК ПЕРЕИМЕНОВАТЬ ФУНКЦИЮ
ШАГ 1. Нажмите на имя функции (например,, 5иЬ_4@10Е0)
I
▼
ШАГ 2, Нажмите К (на клавиатуре)
I
▼
ШАГ 3- Введите новое имя:
[СИескРа55ногс1 ]
(ОК) (Сапсе1)
1---------------------------------------------------------1 I
I I
▼ I
ШАГ 4. Нажмите ОК |
I I
▼ I
РЕЗУЛЬТАТ: |
хпТ __сс1ес! СЬескРаззыогсЦ 1гг1: а1, 1п1 а2)
I
Теперь имя понятное!
Какие имена давать:
Было Стало Почему
5иЬ_401000 СЬескРа$5могс1 Проверяет пароль
Ы|Ь_401100 ЕпсгурТОэ^а Шифрует данные
5иЬ_401200 □есгурЮа^а Расшифровывает данные
5ЫЬ_401300 7а11с1а1:е1при1 Проверяет ввод
5иЬ_401400 1п11Ме1:ыогк Инициализирует сеть
аиЬ_401500 5епс1Раске1: Отправляет пакет
73. Как переименовать переменную (М)
Переменные тоже можно1 переименовывать. Это делает код гораздо понятнее.
I--------------------------------------------------------------------------1
КАК ПЕРЕИМЕНОВАТЬ ПЕРЕМЕННУЮ
До переименованиям , . 1
1 1 1 1п1: сйес! СЬескРаззиогсЩпТ а1, 1П1 а2) 1 { II | 1п1: уЗ; || 1П1 у4; | уЗ = 51 + 16; || | у4 = 5иЬ_40110О(уЗ); | | ге!игп у4 == а2; 1 } II ! Е 1
ШАГ 1. Нажмите на переменную а1
т ШАГ 2. нажмите И | 1 1
ШАГ 3. Введите новое имя:
1 1 [изегТпри! ] | (ОК) (Сапсе1) | | 1 1 |
1 1 т ШАГ 4. Повторите для всех переменных
Пос ле п е реиме нов ан ия:
1 1 1 1лТ сйес1 СНескРаьБыогчЦс^аг* изегТпри!:, 1П1 НаьК) И II 1п1 елсгур^ей; 1П1 с1есгур1ес1; епсгур<:ес1 = изегТпри! + 10; <1есгур1ес1 = ЕпсгургРэгаСепсгургей);
геТигп с!есгур1:ес1 = НазК;
I I } II
I 1---------------------------------------------------------------1 I
I I
| ТЕПЕРЬ ПОНЯТНО! |
I I
I______________________________________________________________________I
Что переименовывать в первую очередь:
Было Стало Почему
а! 1при1 ИЛИ Ьи^ег Входные данные
а2 512е или Хеп^и Размер данных
VI соип^ег Счётчик цикла
у2 геви11 или 1етр Результат или временная переменная
уЗ 1паех Индекс в массиве
у4 51а1иь Статус операции
7.4. Как добавить комментарий (;)
Комментарии — это ваши заметки. Вы пишете их для себя, чтобы не забыть, что
делает код.
ЪехТ
I-------------------------------------------------------------------1
| КАК ДОБАВИТЬ КОММЕНТАРИЙ |
I------------------------------------------------------------------1
I I
ШАГ 1. Нажмите на строку кода^ к которой хотите добавить
комментарий
I I I
I ’ I
ШАГ 2. Нажмите ; (точка с запятой)
I I I
I ▼ I
ШАГ 3. Введите комментарий:
[Проверяем, что длина пароля равна 5]
(ОК) (Сапсе!)
ШАГ 4. пахните ОК
РЕЗУЛЬТАТ:
Лех!: 00401903 стр еах, 5 ; Проверяем,, что длина
пароля равна 5
I 1-----------------------------------------------------------------------------' I
I I
I____________________________________________________________________________________I
Что писать в комментариях:
Что делает эта часть кода — “Проверяем длину пароля"
Почему это важно — "Длина должна быть 5, иначе ошибка"
Что я понял — “Здесь происходит шифрование Х<Ж'
Что ещё нужно проверить — ' Проверить, что делают функции $иЬ_401100 и
5иЬ_4О12ОО"
Переменные и их значения — "еах - длина введённого пароля"
7.5. Как переименовать метку (1М)
Метки — это места в коде, куда программа переходит (]итр). Они тоже имеют
автоматические имена.
I------------------------------------------------------------------1
КАК ПЕРЕИМЕНОВАТЬ МЕТКУ
До переименования
. Тех!:00461000 стр еах, 5
.Тех!:00401003 ЗП2 1 ос_401040 * АВТОМАТИЧЕСКАЯ
ЛехТ: 00401005 риьИ о-ЕТ&еТ аЗиссеьз
ЛехТ :0040100Д са11 _рГ1ПТТ
.т1:0040100Е }тр 1ОС_401050
ЛеЛ: 00401040 1ос_401040: ч- СЮДА ПРЫГАЕТ
.Тех!=00401040 рц^Н О’Нье! аЕггог
Лех! =00401045 са11 _рг1п1^
| ЛехТ: 00401050 1ос_401050:
I__________________________________
ШАГ 1. Нажмите на 1ос_401040
ШАГ 2. ШАГ 3. V Нажмите И 1 т Введите новое имя:
1 [еггог. _ЬапсПег 1 1 1
1 (ОК) 1 (Сапсе!) 1 1
1 ▼
После переименования:
। | Лех! = 00401000 стр еах, 5
| .Тех!=00401003 }пг еггог_Иап<Иег * ПОНЯТНО!
| Лех! = 00401005 риз К оТ-Еве! аБиссезз
| Лех* =00401004 саП _рг1г1Е
| ЛехТ =0040100? }тр епй-'Еипс^хоп
1 ЛеЛ =00401040 еггог_ : *- ПОНЯТНО!
1 Лех* =00401040 ри5К О’Г-Г^е^ аЕггог
1 ЛехТ =00401045 саП _рг1п1:Т
1 лех!=00401050 епс! Типгтюп:
! 1
7,6. Групповое переименование (для продвинутых)
Иногда нужно переименовать много похожих функций. Это можно сделать с
помощью ЮА Ру1Ноп, но это тема Главы. 14.
Пока просто знайте, что такая возможность есть.
7.7. Практика: превратите нечитаемый код в понятный
Теперь давайте применим всё на практике.
Задание 1. Переименуйте функцию
1. Откройте файл в ЮА
2. Найдите функцию зиь_40100й или любую другую
3. Поймите, что она делает (посмотрите код, строки, вызовы)
4. Нажмите и переименуйте её в сьескРаззиогс! или
5. Посмотрите, как изменился код
Задание 2. Переименуйте переменные
1. Откройте С-псевдокод (Р5)
2. Найдите переменные VI, ч2, а1, а2
3. Нажмите на них и переименуйте в 1при1, $1гег гезиП:
4. Посмотрите, как код стал читаемее
Задание 3. Добавьте комментарии
1. Найдите строку с условным переходом Си, стр)
2. Нажмите; и добавьте комментарий
3. Объясните, что происходит на этой строке
4. Добавьте комментарии к нескольким ключевым строкам
Пример результата:
Гехт
---------------------------------------------------------------
ПРИМЕР: ПОСЛЕ ПЕРЕИМЕНОВАНИЯ
Было:
1П1 __сс!ес1 зиЬ_401000( 1гН; а1, 1п1 а2)
I { II
I хЗ; | |
| уЗ = зиЬ_401100(э1); | |
| 1-Р ( УЗ == а2 ) ||
ге1игп 1;
геТигп 0;
I ) II
1---------------------------------------------------------------* 1 I
Стало:
I---------------------------------------------------------------1 I
// Проверяет, совладает ли хвш пароля с ожидаемым
1п1 __сс!ес1 СЬескРаззногс1(с1таг* изегТири!:, 1п1 ехресТе^НазЬ) |
I { II
1п1 эсТиаТНа^Ь;
// Вычисленный хэш пароля
// Вычисляем хэш от введённого пароля
ас1иа1НагЬ = Са1си1атена5Ь(и^ег1при^);
// Сравниваем с ожидаемым хэшем
1-Р ( эскиаШазН == ехресЕейНаэК )
ге^игп 1;
ге!игп 0;
// Пароль верный
// Пароль неверный
ТЕПЕРЬ ВСЁ ПОНЯТНО!
7.8. Карта действий: переименование и комментарии
КАРТА ДЕЙСТВИЙ: ПЕРЕИМЕНОВАНИЕ И КОММЕНТАРИЙ
1. ОТКРЫТЬ ФАЙЛ В ЮА * Глава 3
I
▼
2. НАЙТИ НУЖНУЮ ФУНКЦИЮ * Используйте строки (5КШ+Р12) |
I
т
3. ПОНЯТЬ, ЧТО ДЕЛАЕТ + Нажмите прочитайте код
ФУНКЦИЯ
I
т
4* НАЖАТЬ И НА ИМЕНИ * Ввести новое имя |
ФУНКЦИИ
I
▼
5. ПЕРЕИМЕНОВАТЬ + Нажать на каждую переменную,
ПЕРЕМЕННЫЕ -+ нажать Ы, ввести новое имя
6. ДОБАВИТЬ КОММЕНТАРИИ + Нажать ; на ключевых строках
7. т ПЕРЕИМЕНОВАТЬ МЕТКИ + нажать м на 1ОС_...
3. т ПРОВЕРИТЬ РЕЗУЛЬТАТ -+ Код стал понятным!
Клавиши: М (переименовать) ; (комментарий)
Совет: Переименовывайте ВСЁ^ что можно< Чем понятнее код - |
тем быстрее анализ,
0 Время: 515 минут на функции
7.9. Сохранение изменений
Все ваши переименования и комментарии сохраняются в ЮВ-файл (или 164 для 64-
битных файлов).
тех* *
-----------------------------------------------------------
СОХРАНЕНИЕ ИЗМЕНЕНИЙ
ЮА автоматически сохраняет изменения в ЮВ-файл:
• Вы переименовали функцию -* сохранилось
• Бы добавили комментарий + сохранилось
* Вы закрыли ЮА -+ всё сохранилось
ЮВ-файл лежит рядом с исходным ЕХЕ:
рго^гаш.ехе
ргоегат.14Ь * Вот здесь все ваши изменения!
Что делать, чтобы не потерять изменения:
1+ ЮА сохраняет автоматически при закрытии
2. Можно сохранить вручную: Е11е -+ Байе
3. Можно сделать копию: ₽11е -* 5а*е аз,,.
Важно: Если вы откроете тот же ЕХЕ-файл в другой папке, ЮА создаст новый ЮВ-
файл. Ваши изменения останутся в старом ЮВ-файле,
Итоги главы
Ы — переименовать функцию, переменную или метку
; — добавить комментарий к строке
Давайте понятные имена — не бойтесь переименовывать всё
Комментируйте ключевые моменты — что делает код и почему
Сохраняйте изменения — ЮА сохраняет их в ЮВ-файл
Читаемый код = быстрый анализ — чем понятнее код, тем легче работать
Теперь вы умеете делать код читаемым. В следующей главе мы разберём
типы данных и структуры — как превратить набор байтов в осмысленные
объекты!
ГЛАВА 8. Типы данных и структуры
8.1. Проблема: ЮА не знает, что за данные перед ней
Когда ЮА анализирует файл, она видит просто байты. Она не знает, что эти 4 байта
— это число, указатель на строку или часть структуры.
ЧТО ВИДИТ ЮА
В памяти:
Дс1с1гез5 ВуТез. 1 Что это?
| 00403000 48 65 6С 6С 6Е + л'Не11о" (строка)
1 00403010 0А 00 00 00 + 10 (число)
| 00403014 00 40 30 00 -* Указатель на 00403000
| 00403018 | 20 00 00 00 -> 32 (число)
Для ЮА это просто байты. Она не знает их значение.
Но вы можете сказать ей: "Это строка 1'^ "Это число! !\
"Это структура!"
I
I_______________________________________________________________
Решение: Задать правильные типы данных. Тогда код станет читаемым, а ЮА
сможет лучше анализировать.
8.2. Как задать тип переменной (V)
Самая важная операция — сказать ЮА, какого типа переменная.
I----------------------------------------------------------------------~I
КАК ЗАДАТЬ ТИП ПЕРЕМЕННОЙ (?)
До задания типа:
хп! __сс1ес1 СЬескРа5 5«огс1( 1п1: а1, 1пТ а2)
I { II
I !* ?3; | |
| уЗ = 2иЬ_401100(а1)* | |
| Ц= ( уЗ == а2 ) ||
ге^игп 1;
геТигл 0;
I } II
1--------------------------------------------------------------1 I
I
Проблема: а1 и а2 - это числа, но на самом деле это может
быть ШАГ ШАГ ШАГ > указатели 1, Нажмите 1 ▼ 2. Нажмите 1 т 3. Введите на строки или структуры. на а1 * 1 правильный тип: 1 1 1 1 1
1 1 1 1 1 1 1 сопл: сКаг* | (ОК) (Сапсе!) | | । । ।
1
После задания типа:
I--------------------------------------------------------------1 I
1ПЬ___с<1ес1 СЬескРаземогеЦсопЛ сИаг* 1при^ 1П1 Ьа$й)
I { II
| 1П1 уЗ; ||
| «3 = 5иЬ_401100(1при1); «- ТЕПЕРЬ ПОНЯТНО! | |
| !? ( УЗ == 113511 ) | |
геСьгп 1;
геТигп 0;
| } II
1--------------------------------------------------------------1 I
Основные типы данных в ЮА:
Тип Что означает Когда использовать
сКаг Один байт (символ) Отдельный символ
1П1 4-байтовое пиело Обычные числа
бНог! 2-байтовое число Маленькие числа
1опе 4-байтовое число (на \Л/1пс1оиУ5) Числа
1оп$ 1оп@ 8-байтовое число Большие числа
сЬаг* Указатель на строку Текстовые строки
УО1С1* Указатель на что-то Неизвестные указатели
вооь Логическое значение (0/1) 1гие/Ы&е
ошоно 4-байтовое беззнаковое Беззнаковые
числа
Тип Что означает
норс 2 -байтовое беззнаковое
вуте 1 -байтовое беззнаковое
Когда
использовать
Беззнаковые
числа
Байты
8.3. Что такое структуры ($1гис1)
Структура — это группа переменных, объединённых в один объект. Например,
точка на экране:
ЪекТ
1 1 ЧТО ТАКОЕ СТРУКТУРА —1 1
В С-коде: 1 1 1 1 1
1 1 1 1 1 1 з!гис1: Ро1п± { 1п1 х; 1 11* у; 1 1 В 1 । 1 □ 1 1 1 1 1 1 1 1 1
В памяти:
1 1 1 1 1 1 Ас1с1ге55 ВуТеь Значение 1 00403000 0А 00 00 00 * X = 10 | 00403004 14 00 00 00 * у = 20 1 1 1 1 1 1 1 □ 1 1 1
В ЮА до задания структуры: 1
I I 1 1 1 1 | а1; // Что это? 1П1 а2; // Что это? I 1 1 1 1 1 1 1 1
В ЮА после задания структуры: 1 1
1 1 1 Р01П1* р; 1
р->х = 10;
р->у = 26;
I ।---------------
8.4. Как создать структуру
Есть два способа создать структуру в ЮА.
Способ 1: Через окно Ьоса! Турез
техт
КАК СОЗДАТЬ СТРУКТУРУ
ШАГ 1. Откройте окно 1_оса1 Туреь 7±еы -> Ореп 5пЬм1е«2 -» 1_оса1 Туреа или нажмите 5МК+Е1
ШАГ ▼ 2. Нажмите Тп^егТ или кликните на значок ‘4й
ШАГ т 3. Введите определение структуры:
1 1 ЕГгис^ РО1П1 { 1 !* х; | 1 у; 1 1 Ь 1 | (ОК) (Сапсе1) | I I
ШАГ 1 т 4. Нажмите ОК
ШАГ т 5, Теперь структура доступна'
_______________________________________________________________________________________________________________________________________________________________________________________________________________________________1
Способ 2: Использовать стандартные структуры №пс!о№
ЮА уже знает многие стандартные структуры Мпдсимз:
±ех1:
I---------------------------------------------------------------------------------1
I СТАНДАРТНЫЕ СТРУКТУРЫ Ы1К00М5 1
Для Ы1п0оыз-программ часто нужны:
I I
• ММОСЬДЗБ - класс окна
• М56 - сообщение
• ВЕСТ - прямоугольник
• РО1МТ - точка
• 5У$ТЕМТ1Мё - датз/время
| * 5ЕСиА,1ТУ_дТТй1ВОТЕ5 - атрибуты безопасности
Как использовать:
1 . Нажмите V на переменной
2 . Введите имя структуры (например,, ЫЮС1-А55*)
3» ЮА сама подставит поля
I I
I__________________________________________________________________________I
8.5. Как применить структуру к переменной
Структура создана. Теперь нужно применить её к переменной.
I--------------------------------------------------------1
КАК ПРИМЕНИТЬ СТРУКТУРУ
До применения структуры:
[ 1 1П1: а1; // п На самом деле это Ро1п1:*
1 1п^ з2; // р->х I
1 1 1п1 аЗ; // ₽->У I
1 1 1 1_ а2 = а1 + 4; аЗ - а! + 8; / I 1
ШАГ 1. Нажмите на переменную а!
ШАГ 2. Нажмите V
ШАГ 3, Введите»
РохгН:*
| (ОК) (Сапсе!)
После применения структуры:
РО1П1Л РО1П1:;
I
ро1пг->х = 10;
рохп1->у = 20;
ТЕПЕРЬ ПОНЯТНО!
8.6. Работа с массивами
Массивы — это группы данных одного типа, расположенные подряд.
ЧТО ТАКОЕ МАССИВ
В С-коде:
1п1 питЬегз[5] = (1, 2., Зл 4, 5);
В памяти:
Ас^ге^з Уа1ие
00403000 01 00 00 00 -* ГШП1ЬеГ5[0]
00403004 02 00 00 00 -+ питЬег5[1]
00403008 03 00 00 00 + питЬег5[2]
0040300С 04 00 00 00 * питЬегЕ[3]
В ХОД:
1пЕ пишЬег^[5];
питЬегз[0] = 1;
питЬегз[1] = 2;
Как указать массив в ЮА:
При задании типа (У) используйте квадратные скобки:
КАК ЗАДАТЬ 1ЧАССИБ
Значение
сНаг[100]
1пТ[10]
Ро1п1[20]
сКаг*[50]
Массив из 100 символов (строка)
Массив из 10 чисел
Массив из 20 структур Ро1л1:
Массив из 50 указателей на строки
Пример:
Ьи-^ег[25б]; // буфер на 256 байт
1П1 5соге$[10]; // 10 оценок
Ро1п1* ро!пТз[5]; // 5 указателей на Ро1п^
8.7. Перечисляемые типы (епит)
Епит (перечисление) — это способ дать имена числам.
ЧТО ТАКОЕ ЕШМ
В С'Коде:
г 1 1 1 1 1 1 епит Со1ог { ЙЕО = 0, СПЕЕМ = 1, ВШЕ = 2 }; 1 1 1 1 1
1 1 1 Со1ог с = КЕО; 1Т (с 6КЕЕМ) { ... 1 } 1 1
в ЮА без епит:
г 1 1 1п{ со1ог = 0; 1-Е (со!ог == 1) { ... 1 // Что значит 0? } // Что значит 1? | | 1
в ЮА с епит:
I 1 1 Со1ог со!ог = ВЕО; 1Т (соЮг == СВЕЕМ) { 1 // ПОНЯТНО! | ... } и ПОНЯТНО’ I 1
Как создать епит в ЮА:
1. Откройте ЬосаПурез (БЫЙ+И)
2. Нажмите 1п5егТ
3. Введите:
епит Со1ог {
КЕО = 0,
6ЙЕЕМ = 1,
ВШЕ = 2
Ь
4. Нажмите ОК
5. Примените к переменной черев V
8.8, Практика: восстановите структуру данных
Теперь давайте применим всё на практике.
Задание 1. Превратите байты в структуру
Представьте, что вы видите такой код:
с
1пТ а1 = 0x00403000;
1гт1 э2 = *(1п1*)(а1 + 0);
1п1 аЗ = *(1пТ+)(э1 + 4);
Ап! а4 = *(1пТ’)(а1 + Э);
1Т (а2 == 10 88 аЗ == 20 88. а4 == 30) {
рг1п^( "ЗиссйЕа!“);
}
Что это? Это может быть структура из трёх чисел
1. Создайте структуру:
С
зггисс {
1п^ $есоп(1;
1п1
ъ
2. Примените её к переменной ах:
Нажмите на а1 -» V -» введите оаса*
3. Код станет понятным;
с
0а1э+ ааТа = (Оа<:а* >0x00403006;
1-р (с1а1:а-НхгзТ == 10 88 йа^а >5есопс! == 20 88 даСа-ЯМгс! == 30) {
рг1п1^("Зиссезз!”);
}
Задание 2. Найдите структуру в своей программе
1. Откройте программу в ЮА
2. Найдите код, где много адресов со смещением (например, [еах+4], [еЬр+8])
3. Попробуйте объединить их в структуру
4. Используйте V, чтобы применить структуру
8.9. Карта действий: типы данных и структуры
Г КАРТА ДЕЙСТВИЙ: 1 ТИПЫ ДАННЫХ И СТРУКТУРЫ I
1
1 НАЙТИ НЕПОНЯТНУЮ *+ 1 1 Посмотрите на переменные
ПЕРЕМЕННУЮ + а1-г э2^ у2
т
1 ОПРЕДЕЛИТЬ ТИП Что это: строка? число?
ПЕРЕМЕННОЙ указатель? структура?
▼ !
1 з. НАЖАТЬ У -> Открыть окна задания типа
т 1
| 4.. ВВЕСТИ ТИП + с(1аг*л 1пТ, РО1П1!:* и т.д.
т I
1 5- (ЕСЛИ СТРУКТУРА) -* Нажать 5Ы-ЕТ+Е1 |
СОЗДАТЬ СТРУКТУРУ ТпзегТ •* ввести зТгисЬ
1
1 6- (ЕСЛИ СТРУКТУРА) -> Нажать У -* ввести имя
ПРИМЕНИТЬ СТРУКТУРУ + структуры
▼ 1
| 7. (ЕСЛИ МАССИВ) * Использовать [] в типе
ЗАДАТЬ РАЗМЕР МАССИВА * сНаг[256], 1П1[10] |
▼ ।
1 з. ПРОВЕРИТЬ РЕЗУЛЬТАТ -+ Код стал понятнее? 1
1 1~^йМ Клавиши: У (задать тип) 1 1 5Ы-РЕ+Е1 (окно структур)
1 / Совет: Правильные типы делают код в 19 раз читаемее!
1 3 Время: 5-20 минут на структуру 1 1
Итоги главы
Типы данных— говорят ЮА, что означают байты в памяти
V — задать тип переменной (главная клавиша!)
Структуры — объединяют связанные переменные в один объект
5ЫН+Г1 — открыть окно структур (1_оса[ Турез)
Массивы — группы данных одного типа (используйте [])
Епит — даёт имена числам (делает код понятнее)
Правильные типы = понятный код — тратьте время на типы, они окупаются
Теперь вы умеете превращать байты в осмысленные структуры. В следующей
главе мы разберём ЕЫКТ и Ьиплта — как ЮА автоматически распознаёт
библиотечные функции!
ГЛАВА 9. ГЫКТ и Ьитта — умное распознавание
9.1. Проблема: тысячи неизвестных функций
Когда вы открываете программу в ЮА, вы видите множество функций с именами
вроде 5иЬ_401О00г 5иЬ_401100,5иЬ_401200,„ Но многие из них— это не уникальный код
программы, а стандартные функции из библиотек
С/С + + Г рг!п1Т, 5Тгстр, шаИос, шешсру, зТгсру И СОТНИ Других.
Г---------------------------------------------------------.
ПРОБЛЕМА: НЕИЗВЕСТНЫЕ ФУНКЦИИ
Что Видит новичок:
5ИЬ_401000
| 5иЬ_401100 | I
| аиЬ_401200 | |
| 5ИЬ_401300 | |
зиЬ_401400 *- А что это? ргхпГ-Г? 51гсшр? что-то своё?
| $иЬ_401500 | |
... 300 функций
I---------------------------------------------------------------> |
I
Вопросы:
? Какие из них - стандартные библиотеки?
? Какие - уникальный код программы?
? Как понять, что делает зиЬ_401400?
Решение: РЫКТ и котта автоматически распознают стандартные функции и дают
им правильные имена.
9.2. Что такое Н.1КТ
Е1_1ГЧТ (Еа51 иЬгагу МепЫтсаИоп апсЗ КесодпИюп Тесбпо1оду) — это технология,
которая сравнивает код в вашей программе с базой известных библиотечных
функций.
КАК РАБОТАЕТ РИЯТ
ШАГ 1. ЮА сканирует код в поисках паттернов
ШАГ 2. Сравнивает с базой сигнатур (516-файлы)
ШАГ 3. находит совпадение: |
-------------------------------------------------------! |
Код в программе: Сигнатура е базе:
| 55 8В ЕС 83 ЕС 10 55 8В ЕС 83 ЕС 10 .., | |
I । * II
Это _рг11тЖ Это _рг1п1Т!
ШАГ 4. ЮА переименовывает функцию:
$иЬ_4014О0 -+ _рг-1ггЫ=
Результат:
_гпа1п + Главная функция
_рг1п1?Е * Стандартная функция (распознана)
_51гстр <- Стандартная функция (распознана)
5иЬ_401500 <- Уникальная функция (не распознана)
I_______________________________________________________________I
Что такое 516-файлы:
Это файлы с расширением .з1§, которые содержат "отпечатки" стандартных
функций. ЮА поставляется с 516-файлами для:
Стандартной библиотеки С (рппй ьГгстр, пла11ос„.)
Стандартной библиотеки С++ (со|Д ап, гад де1еХе...)
Библиотек УУ1пс1о№ (кегпе132, и&ег32, дс1|32...}
И многих других
9.3. Как ЮА применяет РЫНТ
Процесс происходит автоматически при загрузке файла, но вы можете управлять
им.
I---------------------------------------------------------------------------1
КАК ПРИМЕНИТЬ РИРТ ВРУЧНУЮ
Если ЮД не применила ЕЫКТ автоматически:
ШАГ 1. Откройте меню:
ЕПе 1оас1 ЕПе * ЕИКТ 518па-Сиге ЕНе
I
▼
ШАГ 2. Выберите 516-файл:
1 1 1 5е1ес^ 51^па^иге -РПе 1 1
| [ус32г1^.51е] + У15иа1 1 С++ гипНте
[ГП57СГ1 -516] + М5УСКТ ИЬгагу
[кегпе132.Б1б] + МХЛЙОкГЗ кегпе132
[и5.ег32 518] 1 -* М1ЛС1о^ изег32 1 1
▼
ШАГ 3. Нажмите ОК
ШАГ 4. ЮА применяет сигнатуры и переименовывает функции
I
Когда применять ШКТ вручную:
• ЮА не распознала библиотеку автоматически
• Вы открыли файл без автоматического анализа
• Вы загрузили файл в КАМ-режиме
• Вы хотите применить дополнительные 51С-файлы
9.4. Что такое 1_итта
1_ит!па — это облачная технология от Нех-Кауз. Она работает как РЫКТ, но
использует базу данных в интернете.
1ех±
I---------------------------------------------------------------------------------1
I ЧТО ТАКОЕ ШМ1МА I
1 1 ГНЕТ (локальный): 1 . 1
1 1 1 Использует 516-файлы на вашем компьютере Работает офлайн Ограничен базой (только известные библиотеки) 1 1 |
1 1 ЦЛПЫА (облачный): _ 1
। । 1 Отправляет "отпечаток11 функции на сервер Нех-Рауз Сервер ищет совпадения в глобальной базе Возвращает имя функции Работает только онлайн Может распознавать уникальные функции, которые уже видели другие пользователи I I I
I I КАК ВКЛЮЧИТЬ ЩМ1ЫД: , , 1
1 1 1 ОрМопз + Сепега1 -> Дпа1у515 -+ 1_ит!па [х] ЕпзЫе 1_ипя1па
1_ 1 ] | 1 1
Преимущества кипгппа:
Распознаёт не только стандартные библиотеки, но и уникальные функции
Использует опыт других пользователей
Постоянно обновляется
Недостатки Ьит1па:
Требует интернета
Отправляет данные о вашем файле на сервер (может быть проблемой для
конфиденциальных файлов)
Иногда может ошибаться (если база данных неверная)
9.5. Когда ШИТ и !_игп1па ошибаются
Ни одна технология не идеальна. Вот когда они могут ошибаться.
ЪекТ
I----------------------------------------------------------1
I КОГДА Н.1КТ/ШМ1КА ОШИБАЮТСЯ I
Случаи 1: Перепутанные функции
I-----------------------------------------------------------------1
5иЬ_401000 + (а это на самом деле свой код)
I_________________________________________________________________I
Решение: Нажмите И и переименуйте обратно,
Случай 2: неправильная версия библиотеки
I-----------------------------------------------------------------1
5-иЬ_401100 -+ _51гсмр (а это _^гстр из другой версии)
I_________________________________________________________________I
Решение: Проверьте, что функция действительно делает.
Случай 3: Пропущенные функции
I-----------------------------------------------------------------1
$иЬ_4012€0 + остается 5иЬ_4#120& (не распознана)
А это на самом деле _метсру
I_________________________________________________________________I
Решение: Примените РИНТ вручную или переименуйте сами,
Случай 4: Ьиштпа дала неправильное имя
I-----------------------------------------------------------------1
зиЬ_401300 + СЬескРа55ыогс1 (из базы Ьиттпа)
А на саном деле это ЕпгурЮаТа
Решение: Не верьте слепо* Проверяйте сами.
I I
I________________________________________________________________________________I
Правило: Никогда не верьте ЕЫКТ и Ылтипа на 100%. Всегда проверяйте, что
функция действительно делает.
9.6. Как отличить стандартную функцию от уникальной
Вот несколько признаков, которые помогут вам понять, стандартная это функция
или уникальная.
1 1 КАК ОТЛИЧИТЬ СТАНДАРТНУЮ функцию 1 1
Признаки СТАНДАРТНОЙ функции: 1 1
Имя начинается с _ (например, _рг1п1Т, _51гапр) Вызывается из многих мест б программе Код короткий и шаблонный Название совпадает с известной функцией С/С++ В окне функций зелёного цвета । 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 Признаки УНИКАЛЬНОМ функции: 1
। X Имя начинается с зиЬ_ (например, 5иЬ_401009) X Вызывается из одного-двух мест X Код большой и сложный X Название не совпадает с известными функциями X В окне функций жёлтого или белого цвета | 1 1 1 1 1 1 —1 1 1 1 1
1 1 Пример: 1
1 _рг1п1^ * СТАНДАРТНАЯ (зелёная, много вызовов) _51гстр *- СТАНДАРТНАЯ (зелёная., много вызовов) | 5иЬ_401Й00 - УНИКАЛЬНАЯ (жёлтая, 1-2 вызова) | $иЬ_401100 <- УНИКАЛЬНАЯ (жёлтая, СЛОЖНЫЙ код) 1 1 1 1 1 1 —1
9,7, Создание своих 516-файлов (для продвинутых)
Если у вас есть своя библиотека, которую вы часто анализируете! вы можете
создать для неё $КЗ-файл. Это позволит ЮА автоматически распознавать ваши
функции.
Ъех!
I-------------------------------------------------------------
КАК СОЗДАТЬ 516-ФАЙЛ
Инструменты Нех-Кау$ для создания
I I
1, Соберите свою библиотеку в Д1Ь или .
2» Используйте утилиту 51^таке.ехе' (в папке ЮА)
3. Создайте 516-файл из библиотеки
4- Положите 516-файл в папку ЮА/51^
5* Примените через Е11е + Ьоас! ЕПе + Е1ЮТ 51^па1иге ЕНе
I I
Это сложно и редко нужно новичкам* Просто знайте, что
такая возможность есть*
I I
I_________________________________________________________________________I
9.8. Практика: распознайте все библиотечные функции
Теперь давайте применим всё на практике.
Задание 1. Проверьте, какие функции распознаны
1. Откройте файл в ЮА
2. Откройте окно функций (СГг! + Е)
3. Посмотрите на цвета:
о Зелёные — распознаны ЕиКТДипгнпа
о Жёлтые — не распознаны
4. Посчитайте, сколько функций распознано, а сколько нет
Задание 2. Примените ЕЫЯТ вручную
1. ЕНе -• 1_оас1 ЕНе -• П1КТ 5|дпаШге ЕНе
2. Выберите (или подходящий для вашего файла)
3. Нажмите ОК
4. Посмотрите, изменились ли имена функций
Задание 3. Включите 1.ит!па
1. Орйопх — Сепега! -» Апа1уз15 - 1ит[па
2. ЕпаЫе ктгнпа
3. Нажмите ОК
4, Подождите, пока ЮА свяжется с сервером
5. Посмотрите, какие функции теперь распознаны
Задание 4. Найдите нераспознанную функцию и назоните её сами
1. Найдите жёлтую функцию (зиЬ_401 ООО)
2. Посмотрите, что она делает (Е5, строки, вызовы)
3. Догадайтесь, как её назвать
4, Нажмите М и введите имя
9.9. Карта действий: распознавание функций
их!
I-----------------------------------------------------------------------1
КАРТА ДЕЙСТВИЙ: РАСПОЗНАВАНИЕ ФУНКЦИЙ
1. открыть файл в юа -» Глава 3
I
т
2. ПРОВЕРИТЬ ФУНКЦИИ * Открыть окно функций (С1г1+Е) |
I
т
В. ПОСМОТРЕТЬ ЦВЕТА •* Зелёные = распознаны
* Жёлтые = не распознаны
I
▼
4. (ЕСЛИ МАЛО РАСПОЗНАНО) -> ЕНе -» 1оа<1 Р11е -+ РИЙТ... I
ПРИМЕНИТЬ РИАТ ВРУЧНУЮ Выбрать 3113-файл
5. (ЕСЛИ ЕСТЬ ИНТЕРНЕТ)
включить ьимюд
Включить кипйпа
ОрМопз * Сепега! -* Ьитхпа
I 6. т ПОДОЖДАТЬ I т ПРОВЕРИТЬ РЕЗУЛЬТАТ (ПЕРЕПРОВЕРИТЬ) I т НЕРАСПОЗНАННЫЕ ФУНКЦИИ - ВРУЧНУЮ 1 * ЮА распознает функции 1 1 - * Проверить, не ошиблась ли ЮА - * Если ошиблась - переименовать 1 1 + Переименовать вручную (Ы) !|
7. 8.
Клавиши: СЬг1+Е (окно функций) И (переименовать)
Совет: Не верьте слепо. Всегда проверяйте, что делает
функция, даже если она распознана.
3 Время: 5-10 минут на проверку 1 1
Итоги главы
РЫКТ — автоматически распознаёт стандартные функции (локально)
Ьигп1па — распознаёт функции через облачную базу (требует интернета)
Цвета в окне функций — зелёные (распознаны), жёлтые (не распознаны)
51С файлы — база сигнатур для ЕЫНТ
Не верьте слепо — ШР.Т и Ьттппа иногда ошибаются
Нераспознанные функции — переименовывайте вручную (М)
Теперь вы знаете, как ЮА автоматически распознаёт функции. В следующей
главе мы переходим к динамическому анализу — отладке!
ГЛАВА 10. Введение в отладку
10.1, Что такое отладка и зачем она нужна
До сих пор мы занимались статическим анализом — изучали код, не запуская
программу. Это безопасно, быстро и даёт 90% ответов. Но иногда статики
недостаточно.
Ъех1:
I----------------------------------------------------------1
КОГДА СТАТИКИ НЕДОСТАТОЧНО
I I Ситуации, когда нужна отладка:
I 1* код СЛИШКОМ СЛОЖНЫЙ | -» Вы не можете понять логику, читая код -» Нужно увидеть, что происходит в реальном времени
1 ДАННЫЕ ГЕНЕРИРУЮТСЯ ДИНАМИЧЕСКИ | * Строки создаются во время работы + В статике их не видно
1 ПРОГРАММА ПАДАЕТ | -* Нужно найти место падения -* Посмотреть, какие данные були & момент падения I
1 1 1 АНТИ-ОТЛАДКА | -* Программа проверяет, не запущена ли она под отладчиком * Нужно обойти эту проверку 1 1
Отладка — это запуск программы под контролем ЮА. Вы можете:
Останавливать программу в любой момент (брейкпоинты)
Смотреть значения переменных и регистров
Выполнять код по шагам
Изменять данные на лету
Смотреть, какие функции вызываются
10.2. Статический у$ Динамический анализ (сравнение)
Давайте ещё раз сравним два подхода, чтобы вы понимали, когда что
использовать.
I---------------------------------------------------------1
СТАТИЧЕСКИЙ УБ ДИНАМИЧЕСКИЙ АНАЛИЗ
СТАТИЧЕСКИМ АНАЛИЗ (Главы 4-9) 1 1 динамический анализ (Главы 10-12) 1 1 1
Анализируете ФАЙЛ
Не запуская программу
БЕЗОПАСНО
Программа не выполняется
БЫСТРО
Секунды-минуты
ВИДИТ ВСЁ, НО НЕ ВСЁ
Видит весь код
НЕ ВИДИТ ДАННЫЕ
не знаетл какие значения
будут в переменных
| Анализируете ПРОГРАММУ
| Запускаете и смотрите
I I I
| ОПАСНО (для вредоносного ПО) |
| Программа выполняется
I I I
| МЕДЛЕННО | |
| Минуты-часы
I I I
I ВИДИТ ТО, ЧТО ВЫПОЛНЯЕТСЯ I |
| Видит только текущий путь
I I I
| ВИДИТ ДАННЫЕ В РЕАЛЬНОМ | |
| ВРЕМЕНИ | |
| Видит значения переменных
' I
ПРАВИЛО:
I--------------------------------------------------------------1
Начинайте со статики (90Я работы).
К отладке переходите только если статика не помогла.
I______________________________________________________________I
10.3. Отладчик в ЮА: локальный и удалённый
ЮА имеет встроенный отладчик. Он может работать в двух режимах.
сехт
-----------------------------------------------------------1
ЛОКАЛЬНЫЙ У5 УДАЛЁННЫЙ ОТЛАДЧИК
ЛОКАЛЬНЫЙ ОТЛАДЧИК
I I I
ЮА и программа работают на ОДНОМ компьютере
I I I
Просто: запускаете программу прямо в ЮА
Быстро: не нужно настраивать сеть
Ограничен: только для вашей ОС
I I I
Используйте: для отладки обычных Ы1пс1оы5/11пих программ
УДАЛЁННЫЙ ОТЛАДЧИК
ЮА на одном компьютере> программа на ДРУГОМ
I
Гибкий: можно отлаживать программы на других ОС
Сложный: нужно настраивать сеть
Медленный: данные передаются по сети
I
Используйте: для отладки Апбго1с1, 105, встраиваемых систем]
Для новичка мы начинаем с локального отладчика. Это проще всего.
10.4. Как запустить программу под отладчиком
Процесс запуска программы под отладчиком простой.
ъехт
I----------------------------------------------------------------------------1
КАК ЗАПУСТИТЬ ПРОГРАММУ ПОД ОТЛАДЧИКОМ
ШАГ 1. Загрузите файл в ЮА (как в Главе 3)
т
ШАГ 2. Выберите отладчик: ОеЬиЕеег -+ 5е1ес^ РеЬияиег Выберите "Ьоса! 141пс1оиз ОеЬи^ег11 (для Ы1пйоы5) ИЛИ "коса! Ыпих ОеЬи^дег” (для 1Лпцх) 1 т
ШАГ 3. Запустите отладку: □еЬивдег + Кип ИЛИ нажмите Г9 1
ШАГ 4, Если программа требует аргументы: □еЬи^еп -* Рпосе^5 орТ1ст..^ Введите аргументы е поле "Рагзте^ег^" 1 т
ШАГ 5. Программа запускается!
Что происходит:
• Программа начинает выполнение
• ЮА показывает текущую инструкцию (жёлтая стрелка)
* Вы можете управлять выполнением
10.5. Основные кнопки управления
Вот ваш минимальный набор для управления отладкой.
ъехт
----------------------------------------------------------1
I ОСНОВНЫЕ КНОПКИ УПРАВЛЕНИЯ
к Р9 ним / С0МТ1ШЕ
Запустить программу или продолжить выполнение
Я Ев 5ТЕР ОУЕК |
Выполнить одну инструкцию. Если это вызов
функции - выполнить её целиком (не заходя)
й Е7 5ТЕР 1КТ0 |
Выполнить одну инструкцию< Если это вызов
функции - войти внутрь неё
(3 «Г1+Е7 5ТЕР ОПТ |
Выполнить код до возврата из текущей функции
И С1Г1+Е2 5ТОР |
Остановить отладку
ГДЕ их НАЙТИ:
I-------------------------------------------------------------------1 I
На панели инструментов (сверху) или в меню ОеЬи^ег
1-------------------------------------------------------------------1 I
10.6. Что вы видите во время отладки
Когда программа запущена под отладчиком, ЮА показывает дополнительную
информацию.
Ъек±
ЧТО ВИДИТЕ 80 ВРЕМЯ ОТЛАДКИ
Основное окно с кодом:
Лех!: 00401000 риьН еЬр II
Лех!: 00401601 ШОУ еЬрл езр * ЖЁЛТАЯ СТРЕЛКА |
Лех!: 00401003 зиЬ езр, ЮЬ
Лех!: 00401066 ПОУ еах, [еЬр+8] II
Лех!: 00401009 са!1 _з!г1еп II
Жёлтая стрелка показывает^ где программа остановилась.
Окно регистров:
ЕАХ = 0000000А
ЕВХ = 00403000
ЕСХ = 00000005
ЕРХ = 00000000
Е1Р = 00401003
Е5Р = 0012ЕЕ00
Текущая инструкция
*- Вершина стека
Отображает текущие значения регистров процессора
Окно стека:
0О12ЕЕ00 00403000
Указатель на строку
I I I 0012ГГ04 00000005 + Длина | | |
| | | 0012ЕЕ08 00401050 -> Адрес возврата || |
I I 1---------------------------------------------------------------Ч I
II II
Показывает содержимое стека.
I 1-----------------------------------------------------------------' I
I I
I__________________________________________________________________________।
10.7. Пошаговая отладка: практика
Давайте пройдём простой пример пошагово.
Пример программы: Проверка пароля.
с
1п1: тахпО {
сЬаг 1при1[100];
рг1пГР("Е|Пег раззмогс!:
Ее*5(ЛприС);
!₽ ($’Сгстр(1пр1г1, ''бесгет") == 0) {
рг’1пТ'Е("Ассе5$ !\п");
} е1ве {
ргхпТ-РС’Ассезз йепте^!\пг|);
}
геТигп 0;
}
ШАГ 1. Загрузите программу в ЮА
ШАГ 2. Нажмите Г9 — программа запускается под отладчиком.
Программа запрашивает ввод. Введите что-нибудь (например, Че$Г).
ШАГ 3. Поставьте брейкпоинт на 81 гетр
Найдите вызов са11 ^тгеюр. Нажмите Р2 на этой строке. Появится красная точка.
ШАГ 4. Запустите заново
Нажмите С1Н+Е2 (остановить), затем Е9 (запустить заново). Программа остановится
на брейкпоинте.
ШАГ 5. Посмотрите на регистры
В окне регистров посмотрите, какие значения передаются в зТгстр:
ЕАХ = указатель на ваш ввод (“(еьГ)
ЕСХ = указатель на строку ''зесгеГ'
ШАГ 6. Выполните по шагам
Нажмите Р8 — выполните $(гстр.
Нажмите Е8 ещё раз — выполните сравнение (1е$1 еах, еах).
Посмотрите на ЕАХ — он равен 0, если строки совпадают или не 0, если нет.
ШАГ 7. Посмотрите на результат
Нажмите Г 8, чтобы увидеть, какое сообщение выводится.
Всё! Вы только что отлаживали программу.
10.8. Карта действий: первый запуск отладчика
Тех!
I------------------------------------------------------------------------------1
I КАРТА ДЕЙСТВИЙ: ПЕРВЫЙ ЗАПУСК ОТЛАДЧИКА |
1. ОТКРЫТЬ ФАЙЛ В ЮА + Глава 3
I
т
2* ВЫБРАТЬ ОТЛАДЧИК -* ОеЬи^ег <♦ 5е1есТ с1еЬи^ег
-» Ьоса! К1пс1о^з/11пих
I
V
3- ЗАПУСТИТЬ ОТЛАДКУ -+ Нажать Р9
-* Или ОеЬи^^ег -+ Кип
I
т
4. (ЕСЛИ НУЖНО) + Ввести аргументы
ВВЕСТИ АРГУМЕНТЫ * В программе запросит ввод
I
▼
5+ ПОСМОТРЕТЬ СТРЕЛКУ -» Жёлтая стрелка показывает
текущую инструкцию
I
т
6. УПРАВЛЯТЬ ВЫПОЛНЕНИЕМ + ЕВ (шаг с обходом)
* Е7 (шаг с заходом)
Е9 (продолжить)
7. СМОТРЕТЬ ДАННЫЕ + Окно регистров
-» Окно стека
I
V
а. ОСТАНОВИТЬ ОТЛАДКУ + С1Г1+Р2
га Клавиши: Е9 (запуск) Е8 (шаг) Е7 (вход) С1Г1+Е2 (стоп) |
/ Совет: Начинайте с Е8 (шаг с обходом). Е7 используйте
только когда нужно зайти в функцию<
А ВНИМАНИЕ: не отлаживайте вредоносное ПО!
I I
[___________________________________________________________________________I
10.9. Особенности отладки разных платформ
Отладка зависит от вашей операционной системы.
сехх
-------------------------------------------------------------
ОСОБЕННОСТИ ОТЛАДКИ РАЗНЫХ ПЛАТФОРМ
Ы1Ю0КБ
I----------------------------------------------------=--=------1 I
Отладчик: коса! кИпао^з
Особенности:
• Поддерживает все версии Шхпйошя
• Может отлаживать 32-битные и 64-битные программы
• Поддерживает БЕН (структурная обработка исключений)
Ш11Х
I--------------------------------------------------------------1 I
Отладчик: Ьоса! Ыпих Оеби^^ег
Особенности:
• Работает через р^гасе
• Требуются права гоо! (или БисГо)
• Поддерживает Е1_Е-файлы
АИОКОЮ
I------------------------------------------
Отладчик: Агк!го1с1 ОеЬияйег* (удалённый)
Особенности:
* Требуется Дпс1го1с1 50К
• Работает через ДОВ
• Отлаживает нативные библиотеки (.50)
I
Итоги главы
Отладка — запуск программы под контролем ЮА
Статика V5 Динамика — 90% времени статика, отладка только при необходимости
Р9 — запуск программы под отладчиком
Е8 — шаг с обходом (не заходит в функции)
П — шаг с заходом (заходит в функции)
С<г1+Е2 — остановка отладки
Жёлтая стрелка — показывает текущую инструкцию
Регистры — показывают текущее состояние процессора
Теперь вы умеете запускать программу под отладчиком. В следующей главе
мы разберём брейкпоинты — как останавливать программу в нужном месте!
ГЛАВА 11. Брейкпоинты и регистры
11.1. Что такое брейкпоинт
Брейкпоинт (точка останова) — это место в коде, где
программа останавливается при отладке. Вы говорите ЮА: "Останови программу
здесь, чтобы я мог посмотреть, что происходит",
±-ЕХ±
I--------------------------------------------------------1
ЧТО ТАКОЕ БРЕЙКПОИНТ
Бев брейкпоинта:
I----------------------------------------------------------------1 I
Программа выполняется от начала до конца
Вы ничего не видите, не успеваете посмотреть данные
1 I 1 1 1 1
С брейкпоинтом:
1 1 1 1 г Программа выполняется + ДОХОДИТ ДО БРЕЙКПОИНТА -+ СТОП Вы смотрите регистры, стек, переменные Нажимаете Е8/Р9 -+ программа продолжает 1 1 1 1 1 4 1 1 1 1
1 1 Визуально: 1 1
1 1 1 Лех!:00401000 ризИ еЬр Лех!:00401001 шоу еЬр, еар ЛехС100401003 еиЬ егр, 10Ь .ТехТ:0040100б шоу еах, [еЬр+8] «- БРЕЙКПОИНТ • лехТ100401009 са11 _51г1еп ЛехТ:0040100Е стр еах, 5 1 1 1 1 1 1 1 1 1 1 □ 1 1 1
1 1 1
11.2. Как поставить брейкпоинт
Поставить брейкпоинт очень просто.
1 1 | КАК ПОСТАВИТЬ БРЕЙКПОИНТ | 1 1'
1 1 1 1 Способ 1: Горячая клавиша
1. Нажмите на строку кода
2. Нажмите Е2
3. Появится красная точка (•)
4. Нажмите Е2 снова - брейкпоинт исчезнет
Способ 2: Клик мышью | . |
1 1 1+ кликните на серую область слева от адреса
2, Появится красная точка (•)
3. Кликните снова - брейкпоинт исчезнет 1 1
Способ 3: Через меню
1* Нажмите на строку кода
2* ОеЬи^§ег * Вгеакро1п15 * Ас1с1 Вгеакро1п1
3+ Нажмите ОК
I____________________________________________________________________I
Где ставить брей к пойнты:
Место Почему
Начало функции Посмотреть, какие аргументы передаются
Перед сравнением Увидеть, что сравнивается
Перед вызовом Увидеть, какие данные передаются
После вызова Увидеть, что вернулось
В месте ошибки Увидеть, что привело к ошибке
113. Типы брейкпоинтов
ЮА поддерживает несколько типов брейкпоинтов,
г------------------------------------------------------I
I ТИПЫ БРЕЙКПОИНТОВ I
ОБЫЧНЫЙ (Бо'РЬгаге Вгеакро1п1)
|---------------------------------------------------------------1 I
Как поставить: Е2
Что делает: останавливает программу на инструкции
Используйте: чаще всего
1---------------------------------------------------------------1 I
I
УСЛОВНЫЙ (Сопсниопа! ВгеакроШ^) |
I---------------------------------------------------------------1 I
Как поставить: ОеЬид^ег -+ Вгеакротп!^ -> Айй...
-* СопДШоп: [еах == Б ]
Что делает: останавливается ТОЛЬКО если условие истинно
Используйте: когда программа проходит место много рзз
Пример: "остановись когда еах станет равен 5"
АППАРАТНЫЙ (Нагйнаге Вгеакрохпг)
Как поставить: □еЪцвдег -> Вгеакрсап^з + А^д...
-* НагсЫаге Ьгеакро1п,1:
Что делает: использует аппаратные регистры процессора
Используйте: когда программа изменяет код (самомодиф.)
1 ' I
I
БРЕЙКПОИНТ НА ДОСТУП К ПАМЯТИ (Метогу БгеакроАпг) |
I-------------------------------------------------------------------1 I
как поставить; ОеЬи&’ег -» Вгеакро1п15 + дса...
-» Метогу Ьгеакротп*
I I I
Что делает: останавливается при доступе к адресу
Используйте: когда нужно узнать, кто изменяет данные
Пример: "остановись когда кто-то пишет по адресу 4030О&"|
I___________________________________________________________
Для новичка: Начинайте с обычных брейкпоинтов (Е2), Они покрывают 90%
задач.
11.4. Как использовать условные брейкпоинты
Условные брейкпоинты — это мощный инструмент, когда программа проходит
через одно место много раз.
ъехт
I-----------------------------------------------------------1
УСЛОВНЫЙ БРЕЙКПОИНТ
Ситуация:
I----------------------------------------------------------------1 I
Цикл выполняется 1009 раз^
Вы хотите остановиться^ когда счётчик станет равен 500.
Без условного Ьрейкпоинта - нажимать Г9 БОЭ раз.
I_______________________________________________________________□
Решение:
1. Поставьте брейклонит на инструкции внутри цикла
2< Кликните правой кнопкой -» ЕйгЕ ЬгеакроЛп!
3. В поле СопЛИоп введите:
I-------------------------------------------------------1 I I
| соип^ег «= 509 | | |
4.. Нажмите ОК
5. Программа остановится только на 500-й итерации
Примеры условий*
еах == 5 + остановиться^ когда еах = 5
еах > 100 + остановиться, когда еах > 100
$1:гстр(1при'1.> "айпйгГ) == 0 -> когда ввели "айтхп"1
еЬр+8 == 0x403900 * когда адрес равен 403000
11.5. Что такое регистры
Регистры — это "карманы" процессора. В них хранятся числа, адреса и результаты
операций.
ТехТ
I------------------------------------------------------------------------------1
ЧТО ТАКОЕ РЕГИСТРЫ
Регистры общего назначения (х86):
ЕАХ = 0Х0000000А + Результат операции
ЕВХ = 0X00403000 * Указатель на данные
ЕСХ = 0X00000005 + Счётчик циклов
ЕОХ = 0X00000000 -+ Дополнительный регистр
Е51 = 0X00401000 -> Источник (ьоигсе хпйех)
Е01 = 0X00402000 -+ Приёмник (Де^ИпаМоп хпёех)
ЕВР = 0Х0012РР00 -+ Базовый указатель стека
Е5Р = 0Х0О12ЕЕЕ0 Указатель вершины стека
Е1Р = 0x00401093 + СЧЁТЧИК КОМАНД (важно!)
Самые важные для новичка:
Е1Р (Н1Р на хб4) - текущая инструкция
Это адрес, где программа сейчас находится.
ЕАХ (НАХ на х64) - результат операции
Большинство функций возвращают значение в ЕАХ.
Е5Р (КБР на кб4) - вершина стека
Показывает, где находится верхушка стека.
ЕВР (йВР на х64) = осноеание стека
используется для доступа к локальным переменным.
Для х64 регистры называются КАХ,, ^ВХ^ КСХ, КОХ и т.д.
11.6. Как смотреть регистры в ЮА
Во время отладки ЮА показывает значения регистров.
Тех!
1 1 1 ОКНО РЕГИСТРОВ В ЮА |
Как открыть: У/1ен -» Орел ЗиЬуДеиа -* ВеехаТегз 1
1 Ке§151:ег5 1 1 1 1 Уа1ие СЬап^ей I I
1 1 1 1 еах 1 1 0000000А * I I
1 1 Е6Х 00403000 | |
1 1 ЕСХ 00000005 | |
1 1 ЕОХ 00000000 | |
1 1 Е51 00401000
1 1 ЕМ 00402000 | |
1 1 Е&Р 0012ЕР00 | |
1 1 Е5Р 0012ЕЕЕ0 | |
Е1Р
00401003 *
| I ЕЕЬАСБ 00000246
I * 1----------------------------------------------------------------------1 I
I I
Звёздочка (*) означает, что регистр изменился на последнем
шаге. Это помогает понять, что произошло.
I________________________________________________________________________________I
11.7. Флаги (ЕПАСЗ)
Флаги показывают результат последней операции. Они используются для условных
переходов.
сект
I---------------------------------------------------------------1
| ФЛАГИ (ЕЕ1.А65)
Самые важные флаги:
ИР (2его Пае) - флаг НУЛЯ
= 1, если результат операции равен й
= 0, если результат не равен 0
Используется в: (]итр 1Т гего), ]П7 (]шр .11? по! гего)|
СЕ (Саггу Е1ае) - флаг переноса
= 1, если было переполнение при сложении
Используется в: ]с С^игпр 1Т саггу), ^пс
БЕ (51НП Е1а&) - флаг знака
= 1, если результат отрицательный
Используется в: 1з (Зитр 1! 1п$
ОЕ (ОиегТ1ош Е1ад) - флаг переполнения
= 1л если произошло переполнение (знаковое)
Пример:
I------------------------------------------------------------------1
стр еах, Б // Сравниваем еах и 5
]г 1аЬе1 // Прыжок, если еах =- 5
I // (2Р = 1) I
Если еах = 5 -> 2Е = 1 * прыжок
Если еах = 3 + 2Е = 0 + без прыжка
1--------------------------------------------------------------------------1 I
I
_________________________________________________________________________________I
11 .8. Практика: поставьте брейкпоинт и смотрите регистры
Теперь давайте применим всё на практике.
Задание 1. Поставьте брейкпоинт на проверку пароля
1. Загрузите программу с проверкой пароля
2. Найдите место, где вызывается 51гстр (или сравнение)
3. Нажмите Е2 на этой строке (поставить брейкпоинт)
4. Нажмите Е9 (запустить отладку)
5. Введите какой-нибудь пароль
6. Программа остановится на брейкпоинте
Задание 2. Посмотрите регистры
1. Откройте окно регистров (У1ем/ -» Ореп $иЬмеиу$ — Кед 15Гег$)
2. Посмотрите, что лежит в ЕАХ, ЕВХ, ЕСХ
3. Найдите, где хранится ваш ввод
4. Найдите, где хранится правильный пароль
Задание 3. Выполните по шагам
1. Нажмите Е8 (шаг с обходом) несколько раз
2. Смотрите, как меняются регистры
3. Дойдите до сравнения (стр или Гез*)
4. Посмотрите на флаги (2Е, СЕ)
Задание 4. Условный брейкпоинт
1. Поставьте брейкпоинт на начало функции проверки
2. Кликните правой кнопкой -• ЕсНГ ЬгеакрснпТ
3. Введите условие: аГгстр(4пр|Л, "зесге*") == е
4. Запустите программу
5. Остановится только если введён правильный пароль
11.9. Карта действий: брейкпоинты и регистры
КАРТА ДЕЙСТВИЙ: БРЕЙКПОИНТЫ И РЕГИСТРЫ
1- ОТКРЫТЬ ФАЙЛ В ЮА Глава 3
2. ▼ НАЙТИ НУЖНОЕ МЕСТО + Используйте строки (51"1гЕ1+Е12)
3. т ПОСТАВИТЬ БРЕЙКПОИНТ + Нажать Е2 на строке
4 + ▼ ЗАПУСТИТЬ ОТЛАДКУ Нажать РЭ
5. ПРОГРАММА ОСТАНОВИЛАСЬ Смотрите на жёлтую стрелку
6. т ОТКРЫТЬ РЕГИСТРЫ * 71ен + Ке^1з1ег5
7. ▼ ПОСМОТРЕТЬ ЗНАЧЕНИЯ -* ЕАХ, ЕВХ, ЕСХ, ЕГР |
8. Т (ЕСЛИ НУЖНО) ВЫПОЛНИТЬ ПО ШАГАМ -+ Нажать ЕВ (шаг) Смотреть изменения регистров
9. т (ЕСЛИ НУЖНО) УСЛОВНЫЙ БРЕЙКПОИНТ -+ Кликнуть правой кнопкой Ей11 Ьгеакро1п1: * СопсИИоп
И Клавиши: Р2 (брейкпоинт) РЭ (запуск) ЕВ (шаг)
Совет: Ерейкпоияты экономят часы ручного прохождения кода.
Используйте их активно!
I I
I__________________________________________________________________________I
11.10. Распространённые ошибки при отладке
Вот что может пойти не так и как это исправить
ОШИБКИ ПРИ ОТЛАДКЕ И ИХ РЕШЕНИЯ
Ошибка: "Программа не останавливается на брейкпоинте”
I----------------------------------------------------------------
Причина: Брейкпоинт поставлен на недостижимый код
Решение: Проверьте, что программа действительно проходит
черев это место. Поставьте брейкпоинт раньше.
I________________________________________________________________
Ошибка: "Брейкпоинт срабатывает слишком чзсто"
I----------------------------------------------------------------
Причина: Брейкпоинт в цикле
Решение: Используйте условный брейкпоинт
I________________________________________________________________
Ошибка: "Не вижу регистры11
Причина: Окно регистров закрыто
Решение; 71ен -+ Орел БиЬухемз *
I________________________________________________________
Ошибка: “Программа падает при запуске под отладчиком-'
Причина: Программа проверяет наличие отладчика
Решение: Используйте плагины для обхода анти-отладки
(Глава 16)
Итоги главы
Брейкпоинт (Е2) — останавливает программу в нужном месте
Условный брейкпоинт — останавливается только при выполнении условия
Аппаратный брейкпоинт — использует регистры процессора
Брейкпоинт на память — останавливается при доступе к адресу
Регистры — показывают состояние процессора
ЕАХ — обычно содержит результат функции
Е1Р — показывает текущую инструкцию
ЕЕЬАСзЗ — содержат флаги (2 Г, СГ, 5Г, ОР}
Теперь вы умеете останавливать программу в нужном месте и смотреть
регистры. В следующей главе мы научимся изменять код прямо во время
отладки — патчинг!
ГЛАВА 12. Патчинг — изменение кода на лету
12.1. Что такое патчинг
Патчинг — это изменение кода программы прямо в ЮА. Вы находите место, где
происходит проверка, и меняете инструкцию так, чтобы программа повела себя
по-другому.
техт
---------------------------------------------------------------------------------1
ЧТО ТАКОЕ ПАТЧИНГ
До патча:
I I--------------------------------------------
1-Е (5{тстр(1пр|Л, "зесгет11) ₽= В) {
рПпт^С'Ассе^ егапТей! ;
} еВе {
рг1ггН("Ассезз йеп1ес!!Г|);
I I }
I I____________________________________________
Ваша цель: обойти проверку и всегда получать "Ассезз §гапТес1!"
После патча:
I---------------------------------------------------------------------1 I
// Проверка удалена или заменена
рг4пТ-Р("Ассе55 дпапТес!1”);
..
I______________________________________________________________________________I
Когда нужен патчинг:
Обход проверки пароля (в легальных целях)
• Исправление бага в программе без исходников
• Изменение поведения программы (например, снятие ограничений)
• Тестирование и эксперименты
12.2. Два способа патчинга
Есть два способа изменить код в ЮА.
сект
П-----------------------------------------------------------
СПОСОБЫ ПАТЧИНГА
СПОСОБ 1: ПАТЧИНГ В ПАМЯТИ (временно)
Изменяете код во время отладки
Изменения действуютпока программа запущена
После перезапуска - изменения пропадают
Когда использовать: эксперименты, тестирование
Клавиша: ЕйхТ -+ Ра^сП рго^гаш -> АзаетЫе
СПОСОБ 2: ПАТЧИНГ В ФАЙЛЕ (навсегда)
Изменяете код в самом ЕХЕ-файле
Изменения сохраняются в файл
При следующем запуске - изменения остаются
Когда использовать: постоянное изменение программы
Клавиша: ЕЙ11 * РаГсИ ргодгат * Арр1у ра^сКез 1прц1...
Для новичка: Начните с патчинга в памяти. Он безопаснее — если что-то пошло
не так, просто перезапустите программу.
12.3. Как заменить инструкцию (АззетЫе)
Самый простой способ патчинга — заменить одну инструкцию на другую.
Ъех1
КАК ЗАМЕНИТЬ ИНСТРУКЦИЮ
ШАГ I. Найдите инструкций, которую хотите изменить
например:
I ЛехТ: 0Э401027 1ос_еггог । I // Прыжок, если не 0 | 1 |
ШАГ 2. Нажмите на эту строку 1
V ШАГ 3. есКГ -> Ра^сЬ ргоегат -* ДъзелЫе или нажмите С^г1+А11+д 1 1
▼ ШАГ 4. Введите новую инструкцию: 1
1 1 пор | (ОК) (Сапсе!) 1 1 1 1 1 1 1 1
1 т ШАГ 5. Нажмите ОК 1
т После патча:
1 | Лех1:00401027 пор // | 1 Ничего не делает! 1 |
I___________________________________________________________I
Важно: Инструкция пор (Ыо Орега^оп) — это "пустышка". Процессор просто
пропускает её и идёт дальше.
12.4, Обход проверки пароля (практика)
Давайте обойдём проверку пароля на реальном примере.
Исходный код (С-псевдокод):
с
1П1 СбескРа5Бшогс1(сопБ1: сНаг* 1при1) {
И (51гстр(1при1л "Бесте!:11) == 0) {
ге111гп 1; // Пароль верный
}
ге1игп в; // Пароль неверный
}
В ассемблере:
1'0X1
Лех1:00401020 саП _51ГСПТр п Сравниваем строки
ЛехХ: 90401025 1е51 еах, еах // про&еряем результат
ЛехХ: 00401027 1ос_1=а11 н Если не 0 -* ошибка
Лех1:00401020 пл<^ еах, 1 и Возвращаем 1 (успех)
Лех!:: 00401012 геТ
Лех1:00401033 1ос_+аИ:
Лех1:00401033 ХОР еах, еах и Возвращаем О (ошибка)
Лех!: 00401035 ге!
Цель: Сделать так, чтобы программа всегда возвращала 1 (успех).
(ехт
! | ОБХОД ПРОВЕРКИ ПАРОЛЯ 1 1 □
Способ 1: Заменить дпг на пор 1 1 1 1 I I
| , 1ех1:00401027 Ш 10С_*а11 // было .1ех1:00401027 пор // Стало
Результат: Программа НЕ прыгает на ошибку. Всегда идёт по
пути успеха.
Способ 2: Заменить }пг на ^тр (прыгнуть всегда) 1 1
Лех!:00401027 ^пг 1ос_ЕаП // Было Лех1:00401027 Згор 1ос_зиссез5 // Стало Результат: Всегда прыгает на успех. Способ 3: Заменить ]П2 на (прыгать если равно) 1 1 1 1 1 1 1 1
1
Лех! =00401027 ^пг
Лех1:00401027 ]2
1ос_ЕаП // было
1ос_ЕаП // Стало
Результат: Прыгает на сшибку ТОЛЬКО если строки совпали..
(То есть наоборот!)
I______________________________________________________________I
Какой способ выбрать?
• пор — самый простой. Просто убираем прыжок.
• ]тр — если нужно прыгнуть е другое место.
• замена условия — если нужно инвертировать логику.
12.5- Как изменить значение в регистре
Иногда нужно не менять инструкцию, а изменить значение, которое лежит в
регистре.
Ее к*
I-----------------------------------------------------------------------------1
[ ИЗМЕНЕНИЕ ЗНАЧЕНИЯ В РЕГИСТРЕ
1 Ситуация: Программа проверяет, чтс еах = 5 1
.Сех1:00401010 стр еах, 5
Лех!:00401013 }пг 1ос_-ГаИ |
Вместо того чтобы менять стр пли Зпз, вы можете изменить
значение ЕАХ прямо во время отладки.
ШАГ 1. Остановитесь на брейклоинте перед стр
т
ШАГ 2. Откройте окно регистров
ШАГ 3. Дважды кликните на ЕАХ
ШАГ 4. Введите новое значение:
I------------------------
I 5
| (ОК) (Сапсе!) | |
I_______________________________________________________________I
ШАГ 5> Нажмите ОК
ШАГ б, нажмите
Теперь
Р8, чтобы выполнить стр
еах == 5 -» проверка пройдена!
12.6. Как изменить данные в памяти
Иногда нужно изменить не код, а данные (например, строку с паролем).
I----------------------------------------------------------------1
| ИЗМЕНЕНИЕ ДАННЫХ В ПАМЯТИ |
I----------------------------------------------------------------1
I I
Ситуация: Пароль хранится в памяти, и вы хотите его изменить. |
I I
ШАГ 1. Найдите строку с паролем (8НгР!+Р12)
ШАГ 2. Перейдите в Нех Утек (Утеш * Ореп ЗиЬитекЕ + Нех сШтр)
I I I
ШАГ 3. Найдите байты строки
I I I
т
ШАГ 4. Кликните правой кнопкой + ЕД1!
ШАГ 5. Введите новые байты:
I I---------------------------------------------------1 I
| | 73 65 63 72 65 74 (секрет) | |
II* II
| | 61 64 60 69 6Е 90 (а<1т1п) | |
I___________________________________________________I I
I I I
| ШАГ 6. Нажмите ОК |
I I
Теперь программа сравнивает ввод с нас1т1п” вместо "весте!".
12.7. КеураиЬ — плагин для удобного патчинга
Кеура1сЬ — это плагин, который упрощает патчинг. Он позволяет изменять
инструкции прямо в ассемблерном коде, не задумываясь о байтах.
I------------------------------------------------------------------------------1
ЧТО ТАКОЕ КЕУРАТСН
Без Кеура1сК:
I----------------------------------------------------------------1
Ес1Н РаТсЬ рго^гагп + АззетЫе
Ввести инструкции
Проверить байты
I ок |
1----------------------------------------------------------------1 I
С Кеура'ЬсК:
I-----------------------------------------------------------------I I
Кликнуть праной кнопкой -» КеурэТсН -+ АзаетЫег
Внести инструкцию
I ОК II
1----------------------------------------------------------------1 I
Установка Кеура1сИ:
I----------------------------------------------------------------1 I
1. Скачайте Кеура1сИ с йИНиЬ
2. Скопируйте в папку ЮЛ/р1о€1п$
3, Перезапустите ЮА
4. Готово1
_________________________________________________________________I
Горячая клавиша: СТгТ+АИ+К
12.8. Как сохранить патч навсегда
Если вы хотите, чтобы изменения сохранились в файле:
1:ех1
КАК СОХРАНИТЬ ПДТЧ
ШАГ
ШАГ
1. Сделайте все изменения в ЮА
2. ЕсШ: ч- Ра1с11 рго^гаш ч Арр1у раТсИеЕ То хпри!: -ЕНе...
ШАГ
3 > Подтвердите:
Арр1у раХсЬез "Со ог1е1па1 Ше?
| [Уез] [Но] [Сапсе!]
ШАГ
4. (Если нажали Уез)
ЮА перезапишет исходный ЕХЕ-файл!
ВНИМАНИЕ!
А Сделайте бэкап файла перед сохранением патча I
ЮА перезапишет оригинальный файл без возможности
отмены!
Совет: Вместо сохранения в оригинальный файд используйте:
• ЕИе -» Ргодисе Я1е -> СгеаТе ЕХЕ Л 1е — создаёт новый ЕХЕ с патчами
• Или просто сохраните ЮВ-файл и не трогайте оригинал
12.9. Практика: обойдите проверку пароля
Теперь давайте сделаем это на практике.
Задание. Обойдите проверку пароля с помощью патчинга
1. Загрузите программу с проверкой пароля в ЮА
2. Найдите проверку (используйте строки и Е5)
3. Найдите в ассемблере инструкцию, которая прыгает на ошибку
4. Замените её на пор [или ]тр на успех)
5. Запустите программу и проверьте, что проверка обойдена
6. (Опционально) Сохраните патч в файл
Шаги подробно:
Ьеи!
1* 5И1К+Е12 -+ найти "Ассеьз РегйесГ
2* Кликнуть по строке -+ прыгнуть в код
3* Посмотреть на 5-16 строк выше + найти ЗпхЛ 32, Зе
4+ Поставить брейкпоинт на эту инструкцию
5. Запустить отладку (Е9)
6. . Когда программа остановится -+ изменить инструкцию
ЕсИ1 -> РаТсН ргодгат -+ АззетЫе •+ ввести ппорИ|
7. Нажать Е9 + программа продолжит
8. Проверить., что проверка обойдена
12.10. Карта действий: патчинг
Г---------------------------------------------------------1
КАРТА ДЕЙСТВИЙ: ПАТЧИНГ
1, НАЙТИ МЕСТО ДЛЯ ПАТЧА 1 -* Строки (5НИ1+Е12) + Код (ГБ) + Ассемблер
2 + т определить, что менять 1 » Условный переход: 1пх, )2 -* Сравнение: стр, 1ев* -» Данные: строка
3. т (В ПАМЯТИ) ИЗМЕНИТЬ КОД 1 -» Е01Т + РаТсЬ ргодгат -» Д55е1пЫе + Ввести новую инструкцию
4 + ▼ (В РЕГИСТРЕ) ИЗМЕНИТЬ ЗНАЧЕНИЕ + Открыть регистры + кликнуть на регистр + Ввести новое значение
5* (НАВСЕГДА) + ЕдИ * Ра1сЬ рго§гаш *
СОХРАНИТЬ 6 ФАЙЛ -» Арр1у ратсйеа Ю 1при1 Щ« |
I
т
6, ПРОВЕРИТЬ РЕЗУЛЬТАТ -+ Запустить программу
Клавиши: СТгТ+АИн-А (АззетЫе) С1Р1+АН+К (КеураТсЬ)
Совет: Начинайте с патча в памяти (без сохранения).
Когда убедитесь, что работает - сохраняйте в файл*
А ВНИМАНИЕ: Патчинг - только для легальных целей!
12.11. Этическое предупреждение
Патчинг — мощный инструмент. Используйте его только для:
* Тестирования своих программ
• Исправления багов в собственном коде
• Обучения и исследований
• Работы с разрешения владельца
НЕ используйте патчинг для:
* Взлома чужих программ
• Обхода лицензионных ограничений
• Любых незаконных действий
Итоги главы
• Патчинг — изменение кода программы прямо в ЮА
• В памяти — временно, до перезапуска
• В файле — навсегда, сохраняется в ЕХЕ
• пор — пустая инструкция, ничего не делает
• АхаетЫе (С(г1+А1|+А) — заменить инструкцию
• Регистры — можно менять значения прямо во время отладки
• КеураТсЬ — плагин для удобного патчинга
• Сохраняйте бэкап перед сохранением патча в файл
Теперь вы умеете изменять код программы! В следующей главе мы
переходим к плагинам — расширяем возможности ЮА.
ГЛАВА 13. Плагины — расширяем возможности ЮА
13.1. Что такое плагины и зачем они нужны
ЮА Рго — это мощный инструмент, но её базовые возможности — это только
начало. Плагины — это дополнительные модули, которые добавляют новые
функции, автоматизируют рутину и делают анализ быстрее и удобнее.
сект
I------------------------------------------------------------
ЧТО ТАКОЕ ПЛАГИНЫ
Бев плагинов:
• Всё делаете руками
• Тратите часы на рутину
• Ограничены базовыми функциями ЮА
С плагинами:
• Автоматизация рутины
• Сложные задачи за секунды
• Новые возможности, которых мет в юд
Почему плагины важны для новичка:
Экономят время (не нужно делать всё вручную)
Упрощают сложные задачи
Делают анализ более эффективным
Расширяют возможности ЮА
13.2. Как устанавливать плагины
Установка плагинов простая.
ТекТ
КАК УСТАНОВИТЬ ПЛАГИН
ШАГ 1. Скачайте плагин
Обычно это файл с расширением .Р11 (ш^пРочэ)
или . $о (Ыпцх) или .йу!хЬ (гаасОБ)
I
т
ШАГ 2. Скопируйте файл в папку с плагинами ЮА
По умолчанию:
Шпионе: С:\Рго§гат ЕНе5\ЮА Рго\р1и^1п5\
Ипих: /ор1/1с1а/р1иё1л5/
тасОЗ; /АррИса? 1оп$/ЮА\ Рго,арр/СоггЕеп1$/р1ив1П5/
I
т
ШАГ 3. Перезапустите ЮА
I
т
ШАГ 4. Плагин появится в меню Ес111 + Р1и^1П5
ИЛИ на панели инструментов
Для плагинов на Руйюгс
Некоторые плагины написаны на РуГНол. Их нужно устанавливать через р!р:
1ех1;
р!р 1п5.1а11 имя_плагина
Или копировать файлы .ру в папку ЮА/руйюп.
13.3. ТОП-5 плагинов для новичков
Вот пять плагинов, которые я рекомендую установить в первую очередь.
г.ехт
ТОП-5 ПЛАГИНОВ ДЛЯ НОВИЧКОВ
Что делает: упрощает патчинг
Как использовать: СТГ1+А1Т+К * ввести новую инструкцию
Зачем новичку: Патчить без головной боли с байтами
I________________________________________________________________I
2+ ЮА РУТНОЙ (встроенный)
I----------------------------------------------------------------1
Что делает: Позволяет писать скрипты на РуТКюл
| Как использовать: рЦе + 5сг1рТ ЕПе...
Зачем новичку: Автоматизировать рутину
________________________________________________________________
3+ Е1ИО5Н1ЕТ5 (или Е1РЮСКУРТ)
I----------------------------------------------------------------1
Что делает: Ищет криптографические константы
Как использовать: ЕЙ1Т -> -+ Е1гк1Сгург
Зачем новичку: находить алгоритмы шифрования
I________________________________________________________________।
4. ШМИЦА (встроенный)
!----------------------------------------------------------------1
Что делает: Распознает функции через облако
Как использовать: ОрИопз * Сепега1 + Дг1а1у515 * Ьш11па
Зачем новичку: Автоматически называть функции
5- 5ТЙ1К65ЕАЙСНЕЙ
Что делает: Расширенный поиск строк
Как использовать: 5еагс1ч + ЗТгтп^еагсЬег
Зачем новичку: Находить строку которые не видны
13.4. Кеура1сЬ — патчинг без головной боли
Кеура1сЬ — это самый полезный плагин для новичка. Он позволяет изменять код в
несколько кликов,
Тех!
Без КеураТсИ (ручная работа):
Г 1 1- Найти инструкцию ^пз 1 II Было
1 2. ЕЙИ -» Ра1сй рго^гат + А$5ешЬ1е
1 в. Ввести "пор" И Стало
1 4. Проверить байты; 90 И пар = 0x90
1 5- 1 ок 1 ।
С КеураТсН:
1 1 1. Кликнуть правой кнопкой 1 на инструкцию
1 2. Кеура1сЬ -+ Д55етЫег 1
1 з. Ввести "пор11 // Стало
1 4- 1 ОК 1 1
Кеура^сГ! также показывает байты, которые меняются:
। | 01(1: ОЕ 85 1 10 00 00 00 (]ГИ)
Мен: 1 90 90 90 90 90 90 (пор * * 6) | Г
I__________________________________________________________I
Горячие клавиши КеураГсН:
С1г1+АК+К — открыть окно А^егпЫег для текущей строки
СП1+АН+Р — показать изменения (патчи)
13.5. ЯпсКгур!— поиск криптографии
ЯпССгур! ищет в программе константы, которые используются в
криптографических алгоритмах.
I------------------------------------------------------------
Е1И05Н1ЕТБ / Р1ШСОРТ
Что ищет*
I---------------------------
* Константы ДЕ5 ($-Ьох)
• Константа 0Е8
• Константы МОБ, 5НА-1, 5НД-2
• Константы СКС
• Константы В5А, ЕСС
• И многое другое
Как использовать:
1. ЕсШ + Р1ие1П5 •+ Е1пс1Сгур1
2. Плагин сканирует файл
3. Показывает результаты:
I--------------------------------------------------------1 I I
| Еоипс1 АЕ5 5-Ьох аг 0x60403000 | | |
Роипс! М05 1пИ1а11га11оп аг 0x00464060
1--------------------------------------------------------1 I I
4, Кликните по результату -> ЮА прыгает в это место
I____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________I
Когда использовать:
* Вы подозреваете, что программа шифрует данные
* Вы ищете алгоритм, который используется в программе
• Вы хотите понять, как генерируются ключи
13.6. ЮА Ру|Ьоп — автоматизация
ЮА РутЬоп позволяет писать скрипты на Ру(Ьоп для автоматизации задач.
ЮА РУТНОМ В ДЕЙСТВИИ
Простейший скрипт:
тгпрогТ: 1йаар1
1гпрог1: 1с1аи1:115
# Вывести все функции
Рог -Гипс 1п 1с1зцШ5.Рипс,Ыоп5();
ргШС'Рипс'Ыоп аГ1, Г1ех(-Рипс))
# Переименовать функции
1с1аар1. зе!_пате (6x401000; "СЬес кРа5 Бшогд")
Как выполнить:
1. ЕНе -> 5сг1р1: Р11е. ♦
2. Выбрать .ру файл
| 3. Нажать ОК
Или выполнить в консоли:
I-------------------------------------------------------------------1 I
1. Е11е -» 5сг1р1 Соттаис!...
2. Ввести код
3. нажать ОК
I___________________________________________________________I
Что можно автоматизировать:
* Массовое переименование функций
• Поиск и маркировка строк
• Создание комментариев
• Экспорт данных в С5УЛ15О1М
• Генерация отчётов
13.7. Где искать плагины
Вот основные источники плагинов для ЮА,
Тех!
I-----------------------------------------------------------1
ГДЕ ИСКАТЬ ПЛАГИНЫ
Официальные ресурсы:
I------------------------------------------------------------------1 I
• Нех-Кау5 Р1и&1п 01гес1:огу
к1ех-г*ау5. сот/ргойисТБ/^а/Биррог^/рТи^тпБ.5Н1т1
I I I
• бИНиЬ (поиск ''1С1а р1и@1п'')
Ё1ТГ1иЬ.со1П/$еагсГ(?С|=1йэ+р1и§1п
I Популярные плагины 1 1 1 (искать на бННиЬ):
I • Кеура^сГ) 1 1 - патчинг
• ПпсГСгур* - поиск криптографии
• ЮАЕсоре - анализ кода
| | * В1П01И - сравнение бинарников
• С1а521пЕогт - восстановление классов С++
| | > ПАРЕ 1 I - набор плагинов от Мапвтап!
1 1 | 1
13.8. Практика: установите и используйте плагин
Задание 1. Установите КеураТсЬ
1. Скачайте КеураГсИ с С^НиЬ
2. Скопируйте файлы в папку р1ид1П5
3. Перезапустите ЮА
4. Проверьте, что плагин появился (Ес1|( -• Р1 ид1пз -» КеураТсЬ)
Задание 2. Используйте Ет^СгурТ
1. Загрузите файл в ЮА
2. ЕсМ — Р1пдт5 — ЯпдСгур!
3. Посмотрите, что нашлось
4. Перейдите по найденным константам
Задание 3. Напишите простой скрипт Ру1Иоп
1, Н1е-• 5спр1 Н1е...
2. Создайте новый файл с кодом:
рутНол
Хтрог! 1с1аар1
ттрог! 1с1аи1:115
# Нойлги и переименовать все функции, нг?чинакициеся с 5иЬ_
Еог ^ипс 1п 1ваи1115 . ЕипсТ1оп5():
лате = 1ваар1^ех_лате(-Еипс)
1-Е пате^агЧгмИгК11 &иЬ_'):
рг1п1(^"Роилй: (пате) а1: { Нех (-Ригс)}")
3. Запустите скрипт
4. Посмотрите на вывод в окне вывода
13.9. Карта действий: работа с плагинами
сект
1 1 | КАРТА ДЕЙСТВИЙ: ПЛАГИНЫ |
1 1 1
1 1 1+ ВЫБРАТЬ ПЛАГИН -* Определить задачу
-* Выбрать подходящий плагин
| 2. СКАЧАТЬ ПЛАГИН + бПНиЬ / Нех-Яауз 511е |
3. УСТАНОВИТЬ ПЛАГИН * Скопировать в папку р1и$1П5
4. ПЕРЕЗАПУСТИТЬ ЮА -» Проверить, что плагин появился 1 1 1
| 5. ИСПОЛЬЗОВАТЬ ПЛАГИН -+ ЕДЦ -» -» имя_плагнна [
| 6. (ДЛЯ СКРИПТОВ) + ЕНе * 5сг1р1 ЕНе... |
| НАПИСАТЬ СКРИПТ + Или ЕНе * 5сг1р± Сопмпапс!.. . | 1 1 1 ===^=^м==а======_=_=^и=3=====ии===1====^= 1
1 1 1 1 Совет: Начните с КеураГсН и Пп^СгурГ - они самые
полезные для новичков.
• Постепенно изучайте скрипты - они экономят часы работы. 1 1 I I
Итоги главы
Плагины — расширяют возможности ЮА
КеураТсН—упрощает патчинг (С1г1 + АН + К)
Нп^Сгур! — находит криптографические константы
ЮА Ру1коп —автоматизация через скрипты
(.иггнпа — облачное распознавание функций
Плагины устанавливаются в папку р1ид!п5
Скрипты можно писать и выполнять прямо в ЮА
Теперь вы знаете о плагинах и можете расширять возможности ЮА. В
следующей главе мы погрузимся в ЮА Ру1Иои — напишем свои скрипты для
автоматизации!
ГЛАВА 14. ЮА РуТЬоп — автоматизация для ленивых
14.1. Зачем писать скрипты
Вы уже познакомились с плагинами, которые делают жизнь проще. Но что, если
вам нужно сделать что-то уникальное? Что-то, для чего нет готового плагина? Или
вы хотите автоматизировать задачу, которую делаете в сотый раз?
ЮА РуТНоп — зто встроенный интерпретатор РуТНоп внутри ЮА. Он позволяет
писать скрипты для автоматизации практически любых действий в ЮА.
1-ЕХ1
I------------------------------------------------------------------------------------1
ЗАЧЕМ ПИСАТЬ СКРИПТЫ
Без скриптов:
I-----------------------------------------------------------------1 I
• 10В функций * 100 раз нажать Ч и ввести имя
• 1000 строк -* 1000 раз кликнуть и переименовать
• 50 структур + 50 раз создать вручную
1-----------------------------------------------------------------' I
I
Со скриптами:
I-----------------------------------------------------------------> I
• функций * один скрипт -* 1 секунда
• 1000 строк + один скрипт + 1 секунда
• 50 структур + один скрипт * 1 секунда
I____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________I
Когда писать скрипты:
Вы делаете одно и то же действие много раз
Бы хотите экспортировать данные в свой формат
• Вам нужно обработать большое количество функций
• Вы хотите создать отчёт по анализу
14.2. Первый скрипт за 5 минут
Давайте напишем первый скрипт. Он будет выводить список всех функций в
программе.
сек*
ПЕРВЫЙ СКРИПТ
I I 1* Откройте ЮА
2* Е11е -+ 5сг1р1 Сотгпапс!. * -
3. Введите код: 1 1
1 1
| | 1трог1: 1с1аиН15 II II
II II рг1п^(“=== Слисок функций ===н)
Еог -Рипе 1п 1с1аи1115. РипсИоп5():
лате = т^аиШз .^е1_^ипс_пате(-ри!лс)
ргхпТ(11 {Ьех (-Еипс)}: {пате}11)
1 1 4+ Нажмите ОК | |
1 1 5- Смотрите вывод е окне вывода (Ои^рц!: Ы1пйош) [ |
1 1 Результат:
1 Г 1 1 | I 0x401000: _51агТ | |
0x401050: _та1п
0x401100: СЬес кРа ззыогс!
| | 0x401200: _ргт1= | |
0x401300: _51гстр 1 । 1 ।
1 1 1 1 I 1
Поздравляю! Вы только что написали свой первый скрипт для ЮА.
14.3, Основные модули ЮА Ру1Ьоп
В ЮА Ру1Ноп есть несколько основных модулей, которые вы будете использовать.
ЪехТ
1 1 ОСНОВНЫЕ МОДУЛИ 1 ЮА РУТНОМ |
т^аиШа - утилиты для навигации 1 1 1 , 1
1 • тдаиТН 5. ЕнпсИопб () • 1с1аи1115.51г1п^б( ) • 1даи1115 .Сос1еВе1:5То(ас1с1г) • гбаиНВ ОаХгаКе-Рз-Та г) | | 1 1 + список всех функций + список всех строк * ссылки на адрес + ссылки на данные 1 |
1с1аар1 - АР1 для работы с ЮА 1 1 1 , 1
! * 14аар1 .^е1_пате(аск1г) • тдаар!.5е1_пагпе( ас^г\ пате) • 1с1аар1 ..^е1:_Еипс_пагпе(аск1г) • 1с1аар1*@;еТ_Ьу1:е(ас1йг) • тбаар! >раТсЬ^у1е(ас1дг> уа1) | | 1 1 * имя по адресу * задать имя * имя функции * прочитать байт - * изменить байт 1 |
Хйа-кеткХп - работа с интерфейсом 1 1 , 1
I * 1да_кегл1лГ1п .т&8( "текст") -* • 1да_кегпи1п. а 5к_1ех{() + • 1с1а_кегпи1п. а ьк_уп () + | | 1 1 вывод в окно вывода запросить текст спросить Уев/Ио 1 |
1 1 1 1
Запомните три главные функции:
Функция
1Даар1 -ее*_пате(асМг)
1с1аар1.зеТ-Пате(ас^Г; пате)
Что делает
Получить имя по адресу
Задать имя по адресу
Функция
Что делает
1даар1,ра1сМ_Ьу1:е(асЮг, уа1ие)
Изменить байт в памяти
14.4. Автоматическое переименование функций
Теперь напишем полезный скрипт — он будет переименовывать все функции,
начинающиеся с 5иЬ_, добавляя к ним префикс.
гехг
АВТОМАТИЧЕСКОЕ ПЕРЕИМЕНОВАНИЕ
Скрипт: переименовывает все виЬ_ функции в ту
I-------------------------------------------------------------
| 1трог-1: 14а иШ 5
| Агорой Хйаар!
[
соип! = в
Тог Типе 1п 1йаи1:115. ЕипсИопз ():
пате = 1с1аар1. Ее1_пате(Типс)
1Т патпе+5ГагТ5ы1ТК("5иЬ_"):
пен-Пате = "ту_н + пате[4:] я убираем ,ь5иЬ_"
1йаар1 + $е-1:_пате(-ЁипсЛ пеы_пате)
соигге += 1
I
рг1п1(€"Переименовано {соып*} функций'1)
Результат:
I Г-------------------------------------------------------------------1 I
| I $иЬ_401000 -* (ПУ-401000 I |
| | 5иЬ_401100 -* ту_401100 | |
| | $иЬ_401200 -» шу_401200 | |
I 1-------------------------------------------------------------------' I
I I
I__________________________________________________________________________1
А теперь более полезный скрипт — переименовывает функции, которые
вызывают определённую строку.
ЪехТ
I--------------------------------------------------------------------------1
ПОИСК И ПЕРЕИМЕНОВАНИЕ ПО СТРОКЕ
Скрипт: находит функцию, которая использует строку "раззкогсГ
и переименовывает её в СПегкРа^^огг!
I
I-------------------------------------------------------------------1 I
тгпрогТ: тйаиШе
тгпрог!: 1с1аар1
I I I
# Ищем строку "раз^ногр"
Рог 5*г1пе 1л 1йаш11$.5Гг'1ПЁ$():
| "раззыога" 10 $1г(5Тг1пе): | |
ргХгтЦ-Е'Найдена строка: {з’ЬгЗ.пе}")
I I I
# Находим ссылки на эту строку
Тог ге^ хп 1с1аи1115.Со<1еКе-Е5То(51г1п1Б.еа1 0):
Рипе = тйаарт. ее!_-Рипс(геТ)
| 1-Е ^ипс: | |
1с1аар1 + 5е1_пате(-(:ипс. 51аг1_еа,
"СИескРа ззиогс! ")
рг!пТ(^"Переименована функция по адресу 11 |
Г^ехС^ипСтЗ-Гаг^еа)}")
I_______________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________I
14.5. Массовое добавление комментариев
Часто нужно добавить комментарии к большому количеству функций.
I—|
КАССОВЫЕ КОММЕНТАРИИ
Скрипт: добавляет комментарий 14 7000: проанализировать11
ко всем функциям, которые не имеют имени.
1
ттрогТ: 1с1аиТ115
тгпрог! 1с1аар1
соипг = 0
Гог -Кипе 1п 1Лаи°С11&<Еипс1:1оп$();
пате = 1Даар1.е&^_пате(Еипс)
1-Р пате 5иг-еэыЛ: 1^1 :
# Добавляем комментарий к функции
1с1аар1. &е1_Типс_ст1:(Еипс,
"ТОСЮ: проанализировать эту функцию"ЕаТзе)
соип! += 1
рг1гЩТГ| добавлено {соип!} комментариев11)
14.6. Экспорт данных в файл
Иногда нужно выгрузить результаты анализа в файд чтобы обработать их в другой
программе.
гекг
ЭКСПОРТ ДАННЫХ
Скрипт: экспортирует список всех функций и строк в СБУ-файл
I----------------------------------------------------------------1 I
1 про г1: 1йаи1115
1трогЧ 1баар1
I I I
ыЦН ореп(и1(1а_ехрог1.с&и’\ V) аз Е:
Т.^гИеС'А^^геБЕ, Иаше Дуре\п")
I I I
Я Экспортируем функции
Тог Типе 1п 1с1аи1115.Гипс11оп5():
паше = 1ааар1«аегвпате(Типс)
Т.кгИгеХТ'Ч Нех (Типе)}. {пате}л ЕипсИопХп")
I II
# Экспортируем строки
•Гог* 51:г1п§ 1п 1йаи1115.5Тг1п§5():
Т. еа)}., {бТгТ^гл-П^)} , 5Тг1п§\п!') I
рг1п1( "Данные экспортированы в 1с1а_ехрогЛ*с5У")
I_____________________________________________________________I
14.7. Интерактивные скрипты
Иногда нужно, чтобы скрипт спрашивал у вас, что делать.
ъех!
—
| ИНТЕРАКТИВНЫЕ СКРИПТЫ |
I-------------------------------------------------------------1
I I
Скрипт: запрашивает новое имя для функции по адресу
1трог1: Ыаар!
ЛтрснЧ Лйа_кегпш1п
# Запрашиваем адрес
асИг_51г = 1с1а_кеггпш1пиа5к_1:ехТ(
"0x401000",
"Введите адрес функции4
)
14= айаг_5-Ьг;
16)
о1<1_пате = Лйаар!. деТ_пате(ас1дг)
# Запрашиваем новое имя
пеш_пате = 1с1а_кеглк1п. азк^ТехЦ
о1с4_пате,
^"Введите новое имя для {Иех(адс1г) }!"
)
1-Е пеи-палпе:
1йаар1 * 5еОаше(всИг, пеы пате)
ргЛпЦ-Р’Функция переименована в {пеы_пате)в|)
14.8. Практика: напишите свой скрипт
Теперь давайте напишем скрипт с нуля.
Задание. Напишите скрипт, который:
1. Находит все строки, содержащие "ра^/огсГ
2. Для каждой строки находит функцию, которая её использует
3. Переименовывает эту функцию в "С1'1ескРа55УУОГсГ
4. Сохраняет отчёт в файл
Тех!
|-------------------------------------------------------------------1
ПРАКТИЧЕСКИМ СКРИПТ
тгпрогТ: 1с1аи1115
1шрог1: 1йаар1
I I I
Роипс! = 0
герогЬ = []
I I I
Рог 1п 1ааии1$.51г'1пе$():
11= "ра$5иогсГ 1п гсг'(згг1пе) .1очег():
героН:. аррепО (-Р Строка: {51г'1пз}")
Сог ге^ 1п 1йаиТ115.Содейе^5То(51г'1ПЁ.еа, 0):
Гипс = 1<1аар1. Ее’Ь_^ипс(ге-Е)
И Типе:
о1й1_пате = 1с1эар1.ве1:_пэте(-#:ипс.5‘1:аг<:_еа) |
1<3аар1.5ег_пате(1ипс. $гаг(:_еа,
"СНескРазаногР")
герогЧ.аррегкЯ-Е’ -> переименована "
{010ате} в СКескРа5$ыог<1") | |
^оипй += 1
I I I
# Сохраняем отчет
«1М1 ореп("раз5ксгс1_аг1а 1у515.1 !\ Иым) аз Т:
€. шг11е (м\п11 *} 01П (герог!))
I I I
рг1пТ(^"Найдено {-Тейпе!} функций связанны* с паролями'1)
рг1п!("Отчёт сохранён в ра$^ога_апа1уз15.Сх^")
1---------------------------------------------------------------------1 I
I
Проверьте скрипт:
1, Откройте файл в ЮА
2. Я1е - 5сг1р1 ЕЯе...
3. Выберите свой скрипт
4. Нажмите ОК
5. Посмотрите результат
14.9. Карта действий: ЮА Ру1Ьоп
-------------------------------------------------------------------------------।
КАРТА ДЕЙСТВИЙ: ЮА РУТНОЙ
1. ОПРЕДЕЛИТЬ ЗАДАЧУ + Что нужно автоматизировать?
* Переименование? Поиск?
* Экспорт? Патчинг?
I
т
2. ОТКРЫТЬ РЕДАКТОР -* ЕПе * $сГ1рТ СомпймЕ.. |
-» Или -* $сг1рт ЕПе...
I
т
3. НАПИСАТЬ КОД -» Используйте модули:
-» 1с1аи1115, 1^аар1э 1^а_кегпм1п|
I
▼
4. ПРОВЕРИТЬ СИНТАКСИС * Проверьте код на ошибки
I
▼
5. ЗАПУСТИТЬ СКРИПТ •* Нажать ОК |
I
т
6. ПРОВЕРИТЬ РЕЗУЛЬТАТ -» Проверить вывод в окне вывода
-» Проверить изменения в ЮА
I
▼
7. (ЕСЛИ НУЖНО) * Исправить код> запустить снова
ОТЛАДИТЬ СКРИПТ
• Совет: Сохраняйте свои скрипты - они пригодятся снова!
т Где смотреть примеры: в1*ЬиЬ + сою/14а-5СГ1р'Е5
I___________________________________________________________________________I
14.10. Полезные приёмы для скриптов
Вот несколько приёмов, которые пригодятся в работе,
гехт
ПОЛЕЗНЫЕ ПРИЁМЫ
Приём 1. Игнорировать стандартные функции
I-------------------------------------------------------------------1 I
# Пропускаем функции из стандартных библиотек | ]
| 51:с1_€ипс5 = [Н_рг1п1-Р, м_з1гапрм, 1|_та11ос'\ 1|_-Ргее“] | |
гР пате 1п $1:с1_-Рипс5:
сопНпие
1------------------------------------------------------------------* 1 I
Приём 2. Работа с диапазонами адресов
I------------------------------------------------------------------1 I
# Перебираем байты в диапазоне
| Гог асИл 1п гапее(0х401@00, 0x462000): | |
Ьу1е = 1с1аар1, ее’Ь-Ьуге^'ас^п)
1-Р Ьу1е == 0x00: # пор
ргл.п’Ц’РНэйден лор по адресу {Кех (асМг)}")
1-------------------------------------------------------------------1 I
I
Приём 3. Поиск по шаблону байтов
Г-------------------------------------------------------------------1 I
# Поиск последовательности байтов
ра1:Гегп = [9x55, 0x86, 0хЕС] # риаИ еЬр; тоу еЬр, еэр |
Гог 1п гап^е(0х401000? 0x402090):
татсН = Тгие
Гог ЬуЕе 1п епитега1:е(ра1Еегп):
гЕ Ыаарт. ееТ буГе^йг + 1) = Ьу1:е:
таГсИ = Еа15е
Ьгеак
1Т ша^сЬ:
рг1п! (^"Найден шаблон по адресу {Ьех(а<к1г) }!1)
I 1-------------------------------------------------------------------------------’ I
I I
I_______________________________________________________________________________________I
Итоги главы
ЮА РуТИоп— встроенный РуТЬош для автоматизации
1с1аи1<15 — для навигации (функции, строки, ссылки)
|<1аар1 — для работы с ЮА (имена, байты, патчи)
Ша кегпшт— для работы с интерфейсом (запросы, вывод)
Скрипты — экономят часы ручной работы
Пишите скрипты для всего, что делаете больше 3 раз
Теперь вы умеете автоматизировать рутину! В следующей главе мы
переходим к работе с АЙМ и мобильными платформами.
ГЛАВА 15. Работа с АРМ и мобильными платформами
15.1. Почему АРМ важен
До сих пор мы работали с х8б и х64 — архитектурами, которые используются в
настольных компьютерах и серверах. Но в современном мире АЙМ встречается
гораздо чаще.
Ъех!
I--------------------------------------------------------------1
ГДЕ ИСПОЛЬЗУЕТСЯ АКИ
О Смартфоны и планшеты
• Апс1го1с1 (почти все устройства)
• 1РН1опе и 1Рай (есе)
И Ноутбуки
* МасВоок на Арр1е ЗШсоп М2Л М3)
• Некоторые Ш1пс1ош5-устройства на АРМ
К Встраиваемые системы
* Роутеры
• Умные колонки
• 1оТ-устройства
Микроконтроллеры
М Игровые консоли
• М1п1:епс1о ЗыНсЬ
| • Р1ау5ииол УИа |
I I
I________________________________________________________________I
Если вы собираетесь анализировать мобильные приложения или встраиваемые
системы — вам нужно знать АКМ,
15.2. АКМ х86: основные отличия
АЯМ и х86 — это разные языки. Вот ключевые отличия.
гехт
[----------------------------------------------------------------1
ДКМ V5 х86
хЗб (сложная архитектура)
1 1 1 1 1 • Много СЛОЖНЫХ инструкций * Инструкции разной длины {1-15 байт) • Мало регистров (8 общих)
| • Регистры: ЕАХ, ЕВХ, ЕСХ, ЕОХ, Е51, Е01, ЕВР, Е5Р
1-------------------------------1-------------------------------------1 I
АРМ (упрощённая архитектура)
1 1 Простые инструкции (все делают по одному действию)
* Инструкции фиксированной длины (4 байта)
• Много регистров (16 общих)
• Регистры: ГШ-Й15
• К0-КЗ - для передачи аргументов
1 КО - возвращаемое значение 1
I____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________I
Самое важное для новичка:
Что делаем
х86
АРМ
Аргументы функции В стеке (ри$Н) В регистрах НО-КЗ
Возврат В ЕАХ В КО
Вызов функции саП Ы (ЬгапсК и/йН Кпк)
Возврат ге1 Ьх 1г (геТигп Го Ипк гедкГег)
153. Регистры АРМ
Вот основные регистры АКМ. которые вы будете видеть.
г----------------------------------------------------------------------------1
РЕГИСТРЫ АРМ
Общего назначения:
I-------------------
НО -+ 1-й аргумент, возвращаемое значение
К1 -+ 2-й аргумент
К2 + 3-й аргумент
КЗ * 4-й аргумент
В4 5-й аргумент (реже)
К5-К11 -+ Локальные переменные
К12 * Временный регистр
Специальные:
Г----------------------------------------------------------------------1 I
К13 (5.Р) Указатель стека
К14 (1_К) -* Регистр возврата (Ипк гедхв’Гег}
К15 (РС) ** Счетчик команд (рго^гат соиггСег)
1----------------------------------------------------------------------* 1 I
I
Пример:
I---------------------------------------------------------------------1 I
1гц СЬескРа$5иог(1(сог1$1Е с*таг* 1приг> {
| // 1ГфЦ1 -> К0 [ |
1-р (51гсгпр(тприТ^ "весте!м) ==• О) {
ге!игп 1; // В0 = 1
}
геТигп б; // Я0 = 0
}
Запомните: На АКМ аргументы передаются через регистры, а не через стек. Это
главное отличие от х86.
15.4. Основные инструкции АКМ
Вот самые частые инструкции АКМ, которые вы встретите.
1ех1:
I---------------------------------------------------------------------------1
ОСНОВНЫЕ ИНСТРУКЦИИ АРМ
Перемещение данных:
1 тоу К0, Р1 -+ ко = Й1 1 1
| 1йг КО, [В1] •+ ко - *К1 (загрузить по адресу)
| 51Г К0, [Й1] * *К1 * = КО (сохранить по адресу)
| ас1г КО , 1аЬе1 * ко = адрес 1аЬе1
1---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------1 I
Арифметика:
1 | ЭС1С1 не, «1> Я2 1 -> В0 = + Я2 ||
54 Ь К0, А1, К2 -> Й0 = К1 - Я2 ||
<пи1 К0, м, А2 -» В0 = Я1 • Я2 ||
1 стр 1 К0, П1 -+ Сравнить К0 и Я1 (устанавливает флаги)| 1
Переходы:
I---------------------------------------------------------------------1 I
Ь 1аЬе1 Безусловный переход
Ьер 1аЬе1 -* Переход, если равно (едка!)
Ьле 1аЬе1 + Переход, если не равно (по^ едиа!)
Ы -Гипс + Вызов функции (ЬгапсН нИН 11пк)
Ьх 1г -* Возврат из функции
15.5. Как загрузить АРМ-файл в ЮА
Загрузка АКМ-файлов почти такая же, как и х86.
1 1 | ЗАГРУЗКА АЙМ-ФАЙЛА |
1 ШАГ 1. Откройте файл в ЮА (РПе -+ Ореп) 1 1 ’ 1 ШАГ 2. В диалоге загрузки выберите процессор: 1
1 Ргосе$5О1' Туре: | [ОК] [СапсеЦ । 1 1 [АЙМ] | | 1 1 1 1
ШАГ 1 т 3. Выберите конкретную 1 1 1 версию АКМ: , 1
। | АН№4 | ДК№5 | АВНу7 | АЙМУ8 (ААГСН64) 1 1 1 + старые устройства - * средние - * большинство Апдго1сЛ - > новые устройстве (64-бит) 1 1
ШАГ 1 т 4. Нажмите ОК 1 1 1 1 1 1
Для Ап<1го1(1-би6лиотек (.во):
Файлы АпскснсЕ обычно используют АЯМу7 или АНМ64
В диалоге загрузки выберите "АКМ" — "АНМу?" или "АКМув"
ЮА автоматически распознает формат ЕЬЕ
Для Ю5-приложений:
Используют АЙМ64 (ААгсЬ64)
• Формат МасН-0 (не Е1Р1)
. Выберите ‘АВМ" - "АКкШ (ААгсЬ64}" - "МасЬ-О"
15.6. Пример: анализ Апс1гогс1 'библиотеки
Давайте разберём реальный пример — проверку пароля в Апс1го1с1-би6лиотеке.
Код на С (исходник):
С
ЗЫ1ЕХРОВТ ^ЬооЗеап ЗЫ1СДЫ
За уа_сот_ехатр1е_арр_Ма 1пАс11 У11у_сЬескРа5 бкогс1 (
1Ы1ЕПУ* епу>
^оЬ^'ес!: 1Мг,
1при1) {
соп51 сЬаг* 31г = (*епу)->бе151г1ПЕОТЕСЬагз(епу| 1при1, МШ_ь);
И (5.1гстр(51г., 1’5есгеТ") == б) {
ге1игп ЗЫ1_ТК11Е;
}
геТигп ЗМ1_ГА15Е;
)
В ЮА (ассемблер АНМ):
10X1
.Тех!:08001234 ркБЬ {г4, 1г} ; сохраняем регистры
.16X1:00001238 т-оу г4, г0 ; сохраняем ЛЧТЕпу
Лех!: 0600123С тоу г0 > г2 ; 1при1 в Н0
Лех!:00001240 Ы 6е151г1л^ТЕСИагз ; вызов 1М-функции
ЛехТ: 00001244 1С1Г г1, =аЗесге! ; загружаем "зесге!11
Лех1:00001248 ШОУ Г4^ Г0 ; сохраняем строку
Лех!: 0000124С Ы 51 гс тр ; сравниваем
Лех!: 00001250 стр Г0^ #0 ; проверяем результат
Лех! = 00001254 Ьер БиссеББ ; если 0 * БиссеББ
Лех!: 08001258 моу Г0, #0 ; геГигп ]М1_ЕА15Е
.1ех1:0000125С рор {г4, ре} ; возврат
.16X1:00001260 Л6x1:00001260 БИСССББ тоу Г0 > #1 ; Ге1игп ЗМ1_ТНиЕ
.16X1:00001264 рор {Г4, рс} ; возврат
В С-псевдокоде (Г5):
ЗЬао1еап 5ауа_са1п_ёхатр1е_арр_Ма1лАс'ЫуИу_сНескРа$з«огс1{
Э&11ЕПУ* епу,,
}оЬ]ес1: Шг,
1при1:) {
сапа* сЬаг* гсг = (*епу)->6е^^г1пвоТРС11^г5(епу, 1приГ? Ш);
(5ггстр(5^г> "зестех") == е) {
ге^игп ЗМ_ТЙИЕ;
}
геТигп 21М11=А1_5Е;
}
Что вы видите:
• Аргументы в КО-К2
• Вызов функции через ы
• Возврат в КО
• рс — это счётчик команд (как Е1Р на х86)
15*7. ТНММВ-режим
На АКМ есть два режима: АКМ (32-битные инструкции) и ТНММВ (16-битные
инструкции),
1?е*Т
!----------------------------------------------------------------!
акм уз тнимв
АЙМ-режим:
----------------------------------------------------------------1 I
* Инструкции по 4 байта
• Больше возможностей
• Используется реже (в основном в ядре)
ТН11МВ-режим:
Г------------------------------------------
• Инструкции по 2 байта
• Меньше возможностей
* Используется чаще (для компактности)
• Распознаётся по нечётным адресам
Как определить режим:
• Адрес функции начинается с четного + АКИ
• Адрес функции начинается с нечётного -* ТНОМВ
• В ЮА это обычно видно по цвету или пометке
I_________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________I
Б ЮА:
Если вы видите в названии функции значит, это ТНСМВ-код:
'Еехт
Лех!:09001234 $цЬ_1234_!ГитЬ
. !ех!:00001238 $1гЬ_1238_!ШтЬ
Обычно ЮА автоматически определяет режим.
15.8. Особенности мобильного анализа
Мобильные приложения имеют свои особенности.
Ьек!
Г--------------------------------------------------------------.
ОСОБЕННОСТИ МОБИЛЬНОГО АНАЛИЗА
А&ЮК010
I---------------------------------------------------------------1 I
• Основной код - Заиа (е .йех/.арк)
• Нативный код - .50 (АВМ/АНМ64)
• 3141-функции имеют длинные имена:
3 а уа_сот_ехатр1е_арр^а1пАс!1711у_сЬескРа5 51агогс1
• Используют 3141ЕПУ для вызова Зауа-методов
105
Г----------------------------------------------------------------1 I
* Основной код - ОЬ^ес! 1уе
• Формат - Мас К-О
• Имена функций: -[МуС1аБ5 шуМеМюс!]
• Используют 0Ь]ес11уе-С гипИгпе
Советы:
I---------------------------------------------------------------1 I
• Ищите строки - они часто остаются е неизменном виде
• 0141-функции легко узнать по имени
• ОИес^уй'С методы тоже имеют говорящие имена
• Используйте Р5 - декомпилятор работает и для ДНИ!
1---------------------------------------------------------------' I
15,9. Практика: проанализируйте простую АКМ-программу
Задание 1. Загрузите А КМ-файл
. Найдите любой АКМ-файл (.50, Е1_Р для АКМ. или пример из интернета)
. Откройте в ЮА
. Выберите правильную архитектуру (АКМ - АКМу7 или АКМу8)
. Дождитесь анализа
Задание 2. Найдите строки и перейдите к коду
. Нажмите 2ЫЙ+Е12
. Найдите строку "$есгеТ" или ра$5УиогсГ
. Кликните по ней дважды
. Нажмите Е5 — увидите С-псевдокод для АКМ!
Задание 3. Сравните ассемблер х86 и АВМ
. Найдите функцию проверки пароля
. Посмотрите на ассемблер АКМ
. Вспомните, как бы это выглядело на х86
. Отметьте различия (регистры, вызовы)
15.10. Карта действий: АЙМ и мобильные платформы
сект:
I I КАРТА ДЕЙСТВИЙ: АЯН И МОБИЛЬНЫЕ ПЛАТФОРМЫ |
1 — 1
1- ! 1 ! ОПРЕДЕЛИТЬ ТИП ФАЙЛА -» .50 <Дпс1го1с1) | | -» МасИ-0 (105) | | -> ЕЬР (Ипцх АКМ) |
иди1 (прошивка)
2. 1 ▼ ВЫБРАТЬ АРХИТЕКТУРУ 1 -> -> 1 1 АКМу7 (32-бит) | АЯМуВ (ААГсНбД, 64-бит) | 1
▼ 1 1
3. ЗАГРУЗИТЬ ФАЙЛ -+ ЕНе » Ореп
1 Выбрать процессор 1
▼ 1 1
4, ИСПОЛЬЗОВАТЬ СТРОКИ + 5ИШ+Е12 ] 1
т 1 1
5. НАЖАТЬ Р5 -> Декомпиляция работает’ |
V 1 1
6- (ОБРАТИТЬ ВНИМАНИЕ) -> Аргументы в К.0-НЗ
НА ОСОБЕННОСТИ АРМ + Возврат в ₽Э
1 *+ Ы вместо са11
1 Ьх 1г вместо ге!:
V Совет: Декомпилятор (Р5) работает и для ДНМ!
|_ Главное отличие; аргументу в регистрах, а не в стеке. I ।
Итоги главы
• АЙМ — самая распространённая архитектура в мобильных устройствах
• Регистры АЙМ — К0-К15, аргументы в ВО-КЗ, возврат в КО
• Основные инструкции — тоу, 1с!г, зГг, асЗс!г зиЬ, стр, Ь, Ы, Ьх 1г
• ТНIIМВ режим — 16-битные инструкции, компактнее
• Апсксис! — .50 файлы, ЛЧ!-функции
• Ю5 — МасК-О, 0Ьуес1г/е-С/$мл11
• Р5 работает для АЙМ — вы по-прежнему читаете С-псевдокод!
Теперь вы умеете работать с АЙМ и мобильными платформами. В
следующей главе мы разберём анализ вредоносного ПО — самые сложные и
интересные задачи!
ГЛАВА 16. Анализ вредоносного ПО
16.1. Что такое вредоносное ПО и почему его анализ —
отдельная история
Вредоносное ПО (малварь, гпакуаге) — это программы, созданные для нанесения
вреда. Они крадут данные, шифруют файлы, следят за пользователями или
используют компьютер для атак.
Анализ малвари отличается от обычного реверс-инжиниринга по нескольким
причинам:
г--------------------------------------------------------1
ОСОБЕННОСТИ АНАЛИЗА МАЛВАРИ
Обычные программы:
I----------------------------------------------------------------1 I
• Код написан понятно
• Строки читаются
• Нет защиты от анализа
• Можно запускать без опаски
Вредоносное ПО:
I--------------------------------------------------------------1 I
• Код обфусцирован (запутан)
• Строки зашифрованы
• Есть анти-отладка и анти-анализ
| | • ОПАСНО ЗАПУСКАТЬ! | |
I 1---------------------------------------------------------------1 I
I_____________________________________________________________________I
Правило №1 анализа малвари: НИКОГДА не запускайте её без виртуальной
машины!
16.2. Подготовка к анализу малвари
Прежде чем начинать анализ, нужно подготовить окружение.
Еех!
ПОДГОТОВКА К АНАЛИЗУ
ИЗОЛИРОВАННОЕ ОКРУЖЕНИЕ
• Виртуальная машина (У1г1иа1Вех, УМнаге)
• Отключенный сетевой адаптер (или изолированная сеть)
* Отключенные общие папки
• Снапшот УМ перед анализом
I__________________________________________________________
ИНСТРУМЕНТЫ
ЮА Рго (установлена е УМ)
Плагины (Кеу, НпаСгурТ., П_АВЕ)
Системные мониторы (РгосезБ МопНог, Ке^БИо!)
Дизассемблеры (для быстрого просмотра)
РЕЗЕРВНОЕ КОПИРОВАНИЕ
Сделайте снапиют УМ перед началом
Сделайте бэкап образца малвари
Сохраняйте все артефакты
163. Упаковщики (раскегв)
Упаковщики — это программы, которые сжимают и шифруют исполняемый код.
Они используются, чтобы:
• Уменьшить размер файла
• Усложнить анализ
• Скрыть реальный код
ЧТО ТАКОЕ УПАКОВЩИКИ
Без упаковщика:
I---------------------------------------------------------------1 I
ргоегат.ехе -» [исходный код) -* ЮА видит всё
I 1----------------------------------------------------------------1 I
I I
С упаковщиком:
I---------------------------------------------------------------1 I
рго^гаш.ехе * [Упаковщик] * [Зашифрованный код]
II । II
При запуске: [Упаковщик распаковывает код в память]
II * II
-+ [Исходный код выполняется]
I 1----------------------------------------------------------------1 I
I I
В ЮА без распаковки:
I I----------------------------------------------------------------I I
Вы видите только код упаковщика
Реальный код зашифрован и невидим
I 1----------------------------------------------------------------» I
I_______________________________________________________________________I
Популярные упаковщики:
Упаковщик Сложность распаковки
ирх Очень лёгкая (есть встроенная распаковка)
АБ Раск Лёгкая
ТНетНа Средняя-сложная
Х/МРгоТес! Сложная (виртуализация кода)
Еп1дта Сложная
ОЬясйит Средняя
16.4. Как распаковать файл
Есть несколько способов распаковать упакованный файл.
Способ 1: Встроенная распаковка в ЮА
Для ШРХ и некоторых других упаковщиков ЮА может распаковать файл
автоматически.
гехг
I----------------------------------------------------------------------1
| РАСПАКОВКА В ЮА |
! Г*
1. Загрузите упакованный файл в ЮА
I I I
I ’ I
2< Если ЮА распознала упаковщик:
Появится сообщение:
| "ТК15 Н1е 15 раскер ыИК ИРХ. Оо уст «апф Фо ипраск 1Ф?“ |
I I I
I ’ I
| 3. Нажмите УЕ5 |
I I I
I ’ I
4, ЮА распаковывает файл и показывает реальный код
I I
(________________________________________________________________________
Способ 2: Распаковка через отладку (ОЕР-метод)
Для сложных упаковщиков используется метод ОЕР (0пд!па1 ЕпТгу Ро!п1г).
ФехФ
1। МЕТОД ОЕР (0ЙП31КА1. ЕИТКУ РОТЙТ) "1 1
1 Запустите программу под отладчиком (Е9) 1 ▼ 1 1 1 1
1 2* Программа останавливается на точке входа упаковщика 1 ч 1 1 1
1 з+ Ставьте брейкпоинты на все вызовы (са!1) 1 1 1
4* Нажимайте Е8 (шаг с обходом), пока не увидите:
• "рорас!" (восстановление регистров)
• "}тр" или "ге1" на неизвестный адрес
I
т
5- Это и есть переход на оригинальный код (ОЕР)
I
т
6, Сохраните "‘дамп*1 памяти в этой точке
I
т
7* Загрузите дамп в ЮА для анализа
Способ 3: Сторонние распаковщики
Существуют инструменты для распаковки конкретных упаковщиков:
Инструмент
IIРХ -д
ОиккОпраск
х64РЬд + 5су11а
ОНуОЬд + ОНуОитр
Для чего
Распаковка 11РХ
Общий распаковщик
Распаковка и дамп памяти
Классический набор
16.5. Обфускация кода
Обфускация — это запутывание кода, чтобы его было сложно читать.
I---------------------------------------------------------------------------1
I ЧТО ТАКОЕ ОБФУСКАЦИЯ |
Обычный код:
I------------------------------------------------------------------------1 I
а (5Сг*стр(1при1:л "гесге!") == 0) {
рг1п1Т( "ЗиссезБ1");
Обфусцированный код:
I-------------------------------------
| хп! а = 0, Ь = е, с = 0;
| Рог (хп* 1 = 0; х < 100; 1++) {
| а += 1 * х;
| Ь += (1 + 1) * (1 + 1);
I Н (а > Ь) {
с = 1приТ[1 % 10];
I }
I }
// что это делает???
Типы обфускзции:
I--------------------------------------------------------------1
• Переименование - функции называются а, Ь, с
• Усложнение логики - добавление мёртвого кода
• Шифрование строк - строки расшифровываются в рантайме
• Анти-отладка = проверка на наличие отладчика
• Виртуализация - код превращается в байт-код
I |
Как бороться с обфускацией:
1. Используйте динамический анализ — запустите программу и посмотрите,
что она делает в реальном времени
2. Трассировка — легируйте все вызовы функций
3. Скрипты — пишите скрипты для автоматической деобфускации
4, Плагины — используйте плагины для распознавания обфускации
16.6. Анти-отладка и как её обойти
Вредоносное ПО часто проверяет, не запущено ли оно под отладчиком.
1ех1:
МЕТОДЫ АНТИ-ОТЛАДКИ
----------------------------------------------------------------------1
1. Проверка флага вехпзоеЬиЗЁес!
I---------------------------------------------------------------1 I
| // ШйЙОИЗ АР1 | |
х-Е (1$0еЬиеее<'Ргебеп,Ь()) {
I ехК(6); | |
I } II
Обход: Используйте плагин Н1деОеЬи^Ёеп
2* Проверка по времени
I-----------------------------------------------------------1 I
// Если выполняется слишком долго -* под отладчиком
| 11= (6«Т1скСоипгО - гтаг! > 1000) { | |
I ехЩ0); | |
I } II
1-----------------------------------------------------------1 I
Обход: Поставьте брейкпоинт на вызове 6еТТ1скСоип1:
3. Проверка 1МТ 3 (6хСС)
I-----------------------------------------------------------! I
И проверяет^ не заменён ли код на 1М 3
| 1* (*((ВУТЕ*Иипс) == 0хСС) { | |
ехИ(О); | |
Обход: Используйте аппаратные брейкпоинты
I___________________________________________________________________________I
Плагины для обхода анти-отладки:
Плагин
ОНуОЬд
НШеОеЬиддег
х64с!Ьд + $су11аН|(1е
ЮА + АпНАпй
Что делает
Имеет встроенные средства обхода
Скрывает ЮА от программы
Мощный набор обходов
Плагин для ЮА
16.7, Что делать, если файл не загружается
Иногда ЮА не может загрузить файл. Вот что делать.
I--------------------------------------------------------------------------1
ФАЙЛ НЕ ЗАГРУЖАЕТСЯ
Причина 1: Повреждённый заголовок
I----------------------------------------------------------------1 I
Решение: Используйте загрузку в КАШ-режиме
В диалоге загрузки выберите:
"Юас! Ыпагу Н1е аз гаи1'
Укажите архитектуру и точку входа
Причина 2: Неизвестный формат
I------------------------------------------------------------------1 I
Решение: Выберите загрузчик вручную
В диалоге загрузки выберите:
| 'Ргосеззог 1уре" * "1п1е1 60x86" или "АЯН" | |
1------------------------------------------------------------------1 I
I
Причина 3: Шифрование
I------------------------------------------------------------------1 I
Решение: Попробуйте отладчик
Запустите файл под отладчиком и посмотрите,
что происходит в памяти
16.8. Практика: анализ простого образца
Давайте разберём реальный (но безопасный) пример анализа малвари.
Пример: Простой троян, который крадёт пароли.
Шаг 1. Определите тип файла
Используйте Ше (Ипих) или рею (У7!пс!охл/5), чтобы узнать, упакован ли файл.
РЕ10 ои!ри1:
Еп1гуро1пТ: 0x40100-0
ЕНе±уре: ЫхпДоиь ЕХЕ
Раскег: 11рх у2.ОЗ
Шаг 2, Распакуйте файл
ирх -а та1иаге*ехе
Шаг 3. Откройте в ЮА
^ех^
Р11е * Ореп + та1ыаге.ехе
Шаг 4. Найдите строки
Нажмите 5ЫН+Е12. Ищите подозрительные строки:
^ех!
" раэзиогсГ'
''10614"
Ъ«р://"
"ста.ехе"
"бегАаупсКеу^аТе"
"5епс11гф1й:''
Шаг 5. Перейдите к функции
Кликните по строке "ра^и/огс!" -» ЮА прыгнет в код — Р5
Шаг 6. Проанализируйте логику
Вы увидите С-псевдокод:
с
1п1 __сс!ес1 51еа1_ра55^ог<15() {
НМЧО Кипе! = Р1пс1Ы1п<1омД(М1Л1 л ,г1ой1п");
1* {
сНзг Ьи-Р-Рег[256]^
беШ1пс1оыТех1:А(Н|НП(11Я 256);
5&п с1То5егуег (Ьи-Нег);
}
геТигп 0;
Шаг 7. Определите С2-сервер
Найдите строки с 1Р-адресами или доменами:
"КПр: //192.168.1.100/106 Р^Р"
"ИНр: //шаИсхоиз.сот/зТеа!"
Шаг 8. Найдите, где хранятся данные
Ищите функции для записи/отправки:
1зех1
СгеаТеШе
ЫггСеРНе
&епс1
ЫБАЗепс!
1п1Ьег'пе,1:0реп0г1А
16.9. Безопасность при анализе малвари
Это критически важно!
Ьех1г
I-------------------------------------------------------
| ПРАВИЛА БЕЗОПАСНОСТИ
I-------------------------------------------------------
I
| А НИКОГДА НЕ ДЕЛАЙТЕ:
I г-----------------------------------------------------
X Не запускайте малварь на рабочем компьютере
X Не подключайте интернет ео время анализа
X Не открывайте малварь на хост-машине
X Не используйте реальные пароли в УМ
I I_____________________________________________________
I
| ВСЕГДА ДЕЛАЙТЕ:
I I-----------------------------------------------------
Используйте виртуальную машину
Отключайте сеть перед запуском
Делайте снапшоты перед каждым запуском
Используйте изолированную сеть (МАТ, Ноь1-Ол1у)
Анализируйте статически (без запуска) как можно дольше|
Удаляйте А/М после завершения анализа
16.10. Карта действий: анализ малвари
Гек!
1 1 | КАРТА ДЕЙСТВИЙ; АНАЛИЗ МАЛВАРИ |
1
1 1* ПОДГОТОВИТЬ УМ * 1 1 1 1 1 1 Создать УМ Отключить сеть Установить ЮА Сделать снапшот 1
1 2- ПРОВЕРИТЬ ОБРАЗЕЦ * 1 Ше / РЕЮ Распознать упаковщик 1
1 3* т РАСПАКОВАТЬ ФАЙЛ + 1 1 1 □рх -с1 (если КРХ) Или через Отладку (ОЕР) |
1 4- т СТАТИЧЕСКИЙ АНАЛИЗ + 1 1 1 1 1 1 Открыть в ЮА 5&Ш+Г12 (строки) | Е5 (декомпиляция) Найти С2-сервер Найти функции кражи
1 т (ЕСЛИ НУЖНО) -* ДИНАМИЧЕСКИЙ АНАЛИЗ -» 1 1 1 Запустить под отладчиком Поставить брсйкпоинты Смотреть регистру Трассировать
1 6“ т СОХРАНИТЬ РЕЗУЛЬТАТЫ -> 1 Экспортировать отчёт
Сохранить ЮВ-файл
7+ ОЧИСТИТЬ УМ -* Восстановить снапшот
* Удалить образец
Д ВАЖНО: Никогда не запускайте малварь без УМ!
Начинайте всегда со статического анализа.
I
I_______________________________________________________I
Итоги главы
• Малварь — вредоносное ПО, требует особого подхода
• Всегда используйте УМ — никогда не запускайте на рабочей машине
* Упаковщики — сжимают/шифруют код, нужно распаковывать
• ЦРХ — легко распаковывается
* ОЕР-метод — распаковка через отладку
• Обфускация — запутывание кода
• Анти-отладка — проверка на отладчик
• Статический анализ — безопаснее, начинайте с него
• Динамический анализ — когда статика не помогает
Теперь вы умеете анализировать вредоносное ПО! В следующей главе мы
разберём использование ИИ для ускорения реверс-инжиниринга.
ГЛАВА 17. ИИ как помощник в реверс-инжиниринге
17.1. Почему ИИ —это новый инструмент аналитика
В 2026 году невозможно игнорировать искусственный интеллект. Нейросети
(СбаГбРТ, С1аис1ег СорИоХ) уже умеют анализировать код, объяснять ассемблерные
инструкции и даже предлагать патчи.
Но, как и любой инструмент, ИИ нужно уметь использовать. Он не заменяет ваш
мозг — он ускоряет вашу работу.
---------------------------------------------------------------------------
ЧТО УМЕЕТ ИИ 8 РЕВЕРС-ИНЖИНИРИНГЕ
ЧТО ИИ ДЕЛАЕТ ХОРОШО;
1 1 • Объясняет незнакомые инструкции * Переводит ассемблер в понятный английский • Помогает понять логику сложных функций • Предлагает имена для переменных • Генерирует комментарии к коду • Ищет паттерны и закономерности । ।
X ГДЕ ИИ ОШИБАЕТСЯ:
1 1 * 1 Уверенно объясняет код, но ошибается в деталях
1 * Придумывает несуществующие функции
1 * Пропускает важные нюансы безопасности
1 * Не понимает контекст (например, стековые фреймы)
1 1— » Предлагает патчи, которые сломают программу Р
I_______________________________________________________________I
Золотое правило: ИИ — это помощник, а не замена вашему мышлению. Всегда
перепроверяйте его выводы.
17.2, Как использовать ИИ для объяснения кода
Самый простой способ использовать ИИ — попросить его объяснить, что делает
кусок кода.
I---------------------------------------------------------------1
| КАК ПОПРОСИТЬ ИИ ОБЪЯСНИТЬ КОД |
I г*
ШАГ 1. Скопируйте код из ЮА (псевдокод или ассемблер)
I I I
I ’ I
ШАГ 2. Откройте СЬа1б₽Т> С1аис1е или другой ИИ-чат
ШАГ 3. Введите лромпт:
I---------------------------------------------------------------1 I
"Объясни, что делает этот код на С.
Напиши простым языком, как для новичка:
I I I
[вставьте код ив ЮА]
1---------------------------------------------------------------1 I
ШАГ 4. Получите объяснение:
I---------------------------------------------------
"Это функция проверки пароля. Она:
1. Принимает строку от пользователя
2. Сравнивает её с сохранённой строкой 'зесгеС’
3. Если совпадает - возвращает 1 (успех)
4, Если не совпадает - возвращает 9 (ошибка)"
Пример промптов для ИИ:
Что нужно
Объяснить функцию
Описать логику
Найти ошибку
Переименовать
Написать комментарии
Промпт
"Объясни, нто делает эта функция на С
"Опиши логику этого кода простыми словами"
"Есть ли в этом коде ошибки или уязвимости?"
"Предложи понятные имена для переменных в
этом коде"
"Добавь комментарии к этому коду"
17.3. Пример: работа с ИИ в реальном анализе
Давайте разберём реальный пример. Вы нашли в ЮА такой код:
с
тпТ _с<1ес1 зиЬ_401Й00(1п1 а1л 1пТ а2) {
1п1 уЗ;
1П1 у4;
сЬэг у5[256];
1п1 Уб;
уЗ = а2;
У4 = 0;
нКНе ( уЗ > 0 ) {
у5[у4] = *(_ВУТЕ ♦)(э1 + у4) а ЙхМ;
у4++;
уЗ--;
}
у5[у4] = 0;
уб 51гстр(у5л в2);
геТигп Уб =» О;
}
Запрос к ИИ:
ЪекХ
''Объясни, что делает этот код на С. Что такое а1 и а2?
Какую логику он реализует?"
Ответ ИИ:
’кехЛ
Это функция проверки^ которая принимает два аргумента:
- аГ: указатель на строку (вероятно^ ввод пользователя)
- а2: длина строки (или указатель на другую строку)
Логика:
1. Копирует строку из а1 в локальный буфер у5
2. Во время копирования ХОй-ит каждый байт с ЭхАА
3. После копирования сравнивает ХОА-строку с а2
4. Возвращает ТЕШЕ (1) если совпадает, иначе ЕА15Е (0)
Вероятно, это функция проверки пароля или лицензионного ключа,
где а2 - это зашифрованное правильное значение.
Как использовать этот ответ:
1. Переименуйте а1 из.ег1при^
2. Переименуйте а? -*• епсгур1еакеу
3. Переименуйте -* сьесккеу
4. Добавьте комментарии:
с
1п1: _сс1ес1 СйескКеу(ссл5Л сНаг* изегТприТ^ соп51 сНаг* епсгурТейКеу) {
сЬаг десгурТей[256];
тлЬ 1=0;
// ХОН-расшифровка каждого байта
мЬНе ( епсгур1ес1Кеу[1] != 0 ) {
десгурхесЦ!] = изегХпркгЦ!] л ЭхАА;
1л+;
}
йесгур1:ей[1] = й;
// Сравниваем с правильным значением
геТигп 51гстр(<1есгур1ес1, епсгурТес1Кеу) 9;
}
17.4. Использование ИИ для переименования переменных
ИИ может предложить хорошие имена для переменных.
I------------------------------------------------------------------------1
ИИ ДЛЯ ПЕРЕИМЕНОВАНИЯ ПЕРЕМЕННЫХ
Запрос к ИИ:
I ----------------------------------------------------------------------1 I
'"Посмотри на этот код. Предложи понятные имена для
всех переменных:
II II
[код с VI, уЗ, а!> а2]
I___________________________________________________________________I |
I I
Ответ ИИ:
I 1---------------------------------------------------------------------1 I
а1 + и5ег!пр'и1:
а2 + ехрес^ейНазИ
| | VI + са1си1а1ес1На5Ь
у2 + хпй1ех
уЗ -* гезиК
I 1---------------------------------------------------------------------I I
I____________________________________________________________________________□
17.5. ИИ для поиска уязвимостей
ИИ может помочь найти потенциальные уязвимости в коде.
±вх1:
I--------------------------------------------------------------------1
| ИИ ДЛЯ ПОИСКА УЯЗВИМОСТЕЙ |
Запрос к ИИ:
I-------------------------------------------------------------
нЕсть ли й этом коде уязвимости? Как их можно
использовать?11
I
[код с 5*гсру, или другими опасными функциями]
I_____________________________________________________________
Отеет ИИ:
11 Да, есть уязвимость переполнения буфера:
1. Функция ее*5(Ьи-Е’Еег) не проверяет длину ввода
2- Пользователь может ввести 26В символовл а буфер
рассчитан только на 64
3* Это приведёт к перезаписи стека и возможному
выполнению произвольного кода
Исправление: замените @е1з(Ьц^ег) на ^е,ЩЪиНгег\
512ео^(Ьи^-Рег) зТЛп)
17.6. Когда ИИ врёт (важно!)
ИИ не идеален. Вот реальные примеры ошибок, которые он может допустить.
Г--------------------------------------------------------------------------1
КОГДА ИИ ОШИБАЕТСЯ
Ошибка 1: Придумывает несуществующие функции
I------------------------------------------------------------------1 I
ИИ: 1!3та функция вызывает с1есгур1_51г1ПЕ(У* 1
Реальность: В коде нет такой функции
Что делать: Проверьте, есть ли функция в коде
I____________________________________________________________□
I
Ошибка 2: Неправильно определяет тип данных
I I--------------------------------------------------------------1
ИИ: "Это массив чисел"
Реальность: Это массив указателей на строки
Что делать: Проверьте, как используются данные
I 1--------------------------------------------------------------' I
I
Ошибка 3: Пропускает важные детали
| -----------------------------------------------------------------
ИИ: "Функция просто копирует данные11
Реальность: В ней есть скрытая проверка на анти-отладку
Что делать: проверьте код на неочевидные инструкции
| I______________________________________________________________!
I
Ошибка 4: Уверен в неправильном ответе
I I--------------------------------------------------------------1
ИИ: "Это точно проверка пароля"
Реальность: Это функция генерации ключа
Что делать: Проверьте логику самостоятельно
I 1--------------------------------------------------------------' I
I I
I_____________________________________________________________________I
Правило: ИИ — это инструмент, а не истина. Всегда проверяйте его выводы.
17.7. Плагины с ИИ для ЮА
Существуют плагины, которые интегрируют ИИ прямо в ЮА.
сект
г--------------------------------------------------------------------1
ИИ-ПЛАГИНЫ ДЛЯ ЮА
1+ сгтсрт-ЮА
।-------------------------------------------------------------1
• Встроенный СНа^СРТ прямо в ЮД
• Выделите код -> запросите объяснение
* Предлагает имена для функций
• Где найти: СИНиЬ / р1и^1П5
I_____________________________________________________________I
2* ТОА-СорПо*
I------------------------------------------
• Помощник на основе бРТ-4
• Автоматически переименовывает функции
• Добавляет комментарии
• Анализирует сложные участки кода
I
3. Аи1:о-Сотте п!
I------------------------------------------------------
• Автоматически добавляет комментарии к функциям
• Использует локальные модели ИИ
* Не требует интернета
I______________________________________________________
17.8. Практика: используйте ИИ для анализа
Задание 1. Объясните код с помощью ИИ
1. Откройте файл в ЮА
2. Найдите функцию (можно использовать любую)
3. Скопируйте С-псевдокод (Е5)
4. Вставьте в СЬаКЗРТ или С1аис!е
5. Попросите объяснить, что делает функция
6. Сравните с вашим пониманием
Задание 2. Переименуйте код с помощью ИИ
1. Возьмите код со странными именами (у1, у2, а1, а2)
2. Попросите ИИ предложить новые имена
3. Вернитесь в ЮА и переименуйте переменные (ГЧ)
4. Посмотрите, как код стал читаемее
Задание 3. Найдите уязвимости с помощью ИИ
1. Найдите код с функциями деЬг ьГгсру, 5рпл{(
2. Попросите ИИ найти уязвимости
3. Проверьте, прав ли ИИ
4. Запомните опасные паттерны для будущего
17.9, Карта действий; работа с ИИ
1ех1
I--------------------------------------------------------------------------1
КАРТА ДЕЙСТВИЙ: ИИ В РЕВЕРСИНЖИНИРИНГЕ
1. ВЫДЕЛИТЬ КОД В ЮА 1 -* -* Скопировать псевдокод (Е5) Или ассемблер
2. т ОТКРЫТЬ ИИ-ЧАТ 1 -к СНаТбРТл С1аис1е, СорИоЬ
3. СФОРМУЛИРОВАТЬ ЗАПРОС 1 -э "Объясни код,г "Переименуй переменные11 11 Найди уязвимости11
4. т ПОЛУЧИТЬ ОТВЕТ 1 + + Прочитать объяснение Запомнить ключевые моменты
5. т ПРОВЕРИТЬ ОТВЕТ 1 -> Сравнить с кодом в ТОД Проверить, не ошибся ли ии
6. т ПРИМЕНИТЬ В ЮА 1 1 "+ + + Переименовать (М) Добавить комментарии (;) Изменить типы (V)
• Совет: Задавайте ИИ конкретнее вопросы.
т ВАЖНО: Всегда проверяйте ответы ИИI
ИИ - это инструмент, а не замена вашему мышлению.
I I
I___________________________________________________________________________I
17.10. Будущее ИИ в реверс-инжиниринге
Что нас ждёт в ближайшие годы?
1'6x1:
БУДУЩЕЕ ИИ В РЕВЕРС-ИНЖИНИРИНГЕ
Уже сейчас:
I------------------------------------------------------------------1 I
• ИИ объясняет код
• Предлагает имена
• Помогает новичкам
1------------------------------------------------------------------1 I
I
В ближайшие 1-2 года:
• полная автоматическая деобфускация
• Распаковка сложных упаковщиков
• Автоматическое восстановление структур
В ближайшие 3-5 лет:
I----------------------------------------------------------------1
• Полный автоматический анализ малвари
• Восстановление исходного кода из бинарника
• ии-агенты, которые делают анализ вместо вас
Но помните:
I--------------------------------------------------------------------- I
? ИИ не заменит человеческое мышление.
Он станет мощным помощником, но аналитик нужен
для принятия сложных решений и проверки результатов.
I-------------------------------------------------------------------1 |
__________________________________________________________________________I
Итоги главы
• ИИ — мощный помощник для реверс-инжиниринга
• Объясняет код — просите ИИ объяснить сложные функции
• Переименовывает — просите предложить понятные имена
• Находит уязвимости — используйте ИИ для поиска проблем
• ИИ ошибается — всегда проверяйте его ответы
• Плагины с ИИ — интегрируют нейросети в ЮА
* Будущее — ИИ станет ещё более мощным, но не заменит человека
Теперь вы вооружены всеми инструментами: от статического и
динамического анализа до плагинов и ИИ. В следующей главе мы соберём
всё вместе в практическом сценарии — разбор сгаскте от начала до конца]
ГЛАВА 18. Разбор сгаскте — от начала до конца
18.1. Что такое сгаскте
Сгаскте — это специально созданная программа для обучения реверс-
инжинирингу. Она содержит защиту (проверку пароля, лицензионный ключ и т.д.),
и ваша задача — взломать её (сгаск) в учебных целях.
тех*
I . . . .......! | ЧТО ТАКОЕ СЙАСКМЕ
। I 1 Цель сгаскте:
1 1 * Найти секретный, пароль или ключ • Обойти защиту (патчинг) | • Понять, как работает защита 1 1 |
1 1 Уровни сложности: 1 , , 1
1 1 1 1 3 Начальный - простая проверка зГгапр И Средний - ХОК, простые алгоритмы * Сложный - обфускацил, анти-отладка? криптография 1 | 1 1
1 1 1 1 Где брать сгаскте;
1 1 1 1 • сгасктез.оле - самый большой сайт с задачами • гоо1>те.ог^ - задачи с проверкой ответа • геуегзтпе.кг - корейский сайт с задачами
1 1 1 1 1 1
18.2, Уровень 1: простая проверка пароля
Давайте разберём сгаскте самого простого уровня.
Описание задачи: Программа запрашивает пароль. Если пароль правильный —
выводит "$иссе$$!‘‘, если нет — "\Л/гопд!".
Программа на С (исходник, который у нас есть):
с
#1пс1ыс1е <зТй1о.^1>
#1пс1ис1е <5Т1~1пе-11>
1пТ та1п() {
сКаг раз5ыогсЦ100];
рг!пЫ:("ЕпТег раззногс!: );
зсап-Р(''%5", раззшогс!);
!? ($хгстр(раззмогс1, "зесгетПЗ") == 0) {
ргхпТ1:("5ш:се$5 ’ \п");
} е1зе {
рг 1пН ( ! \п " ) >
}
геТигп 0;
}
Ваша задача: Найти пароль, не глядя е исходник.
Пошаговый разбор:
ШАГ 1. Загрузите сгаскте в ЮА
Ьек!
РПе -» Ореп •+ сгаскте!.ехе
Дождитесь завершения анализа
ШАГ 2. Найдите строки
Нажмите 5НИЧ+Е12. Вы увидите:
|--------------------------------------------------------------------------------1
ОКНО СТРОК
ДсИгезз 51:г1пе
90403000 "ЕпТег раББЫОгд: "
06403020 "Зиссезз!" |
00403040 '‘Нгопе!4
| 00403060 "зесгеИгЗ"
(__________________________
* ВОТ ОН!
I
ШАГ 3. Найдите, где используется строка "$есге1123”
Дважды кликните по строке "зесгепгз" ЮА прыгнет в код.
ШАГ 4. Посмотрите на код вокруг
Вы увидите что-то вроде:
Лех!: 00401030 РО!5& О-Е^$е! г$есге!123 ; "$есге$123
Лех!: 00401035 рцзй (&Ьр-0СН] ; ваш ввод
Лех! :0040103В са11 _5.!гСП1р
Лех!: 00401030 !&5! еахл еах
Лех! :0640103Е 1П2 шгоп^__1аЬе1
Лех!: 00401041 ричЬ □ЛРзе! аБиссезз ; "Биссезз!”
Лех!: 00461046 са11 _рг1п1!
Лех! :0040104В 3«пр епс!_1аЬе1
Лех!: 00401040 игог>ё_1аЬе1:
Лех! = 00401040 ригЬ ангоп^ ; "Иголе!"
Лех!: 00401052 са!1 _рг1п1:^
ШАГ 5. Нажмите ГБ для декомпиляции
С
Ап'Ь та1п() {
сМаг рэ$5иогс1[100];
рг1п^-Г("Ептег разноге!:
5сап-Р("%$", раззыогй);
И (51гстр(ра5 5ыог(1, "зесгеИгз"} == 0) {
рг1П‘1:Т( “Биссе 55! \п'');
} е1зе {
рг1П1Т(“Ыгоп®!\л");
}
геТигп 0;
}
ШАГ 6. Прочитайте пароль
Пароль прямо в коде: "зеспепгз"
18.3. Уровень 2: проверка с ХОН-шифрованием
Теперь усложним задачу. Программа использует ХОК для шифрования пароля.
Программа на С (исходник):
#1пс1ис1е <5^10,К>
#1пс1ис1е
1п1 та!п() {
сЬаг 1пры1=[100];
сЬэг епсгур!ед[] - (0x1^ 0х0ВЛ 0х1С, 0x0Е^ 0х1А, 0x00);
сИаг кеу = 0х5Д;
рг1л1Т("ЕпХег рз$5ыог<1: ”);
5сал,Е(|,%5", 1приТ);
1П1 1=0;
шМ1е (1приТ(х] !.= О) {
1приТ[1] = 1при1[1] л кеу;
}
Н {^гсгпрЦпри^ епсгур^сс!) == 9) {
рг'1п1-р("5иссе55 ’ \п");
} е1$е {
рг "ыгопд! \п");
}
ге!игп И;
}
Ваша задана: Найти пароль.
сект
I---------------------------------------------------------------------------1
АНАЛИЗ ХОВ-СКАСКМЕ
ШАГ 1. Загрузите файл в ЮА
ШАГ 2. 5ЫТ1+Е12 -+ ищем строки
ШАГ 3, Находим строку "Зиссеза!" -+ кликаем -* Р5
ШАГ 4. Видим код:
1П1: гпа1п() {
сЬаг 1приТ[100];
сЬаг епсгур!ес1[б] = {0х1А, &Х0В, 0х1С, 0х0Е^ 9х1А}; |
сЬаг кеу = ЭхБА;
I I I
рПпгТС'ЕпГег раз$ногй: ");
| 5сап-Р( "%$' ", 1при±); | |
I I I
•Еог (1П1 1 = 0; АприЦ!] != О; 1++) { | ]
1при1[1] = 1при1:[1] л кеу;
I } II
I I I
1-Е (51гсгпр( 1при1, епсгур1ес!) == &) {
| рг1п1-Е( "!>иссе$2! \п"); | |
I } е1зе { | |
| рг1паь-Е:("и1гс1П'е! Хп” | |
I } II
I } II
1-------------------------------------------------------------------1 I
I
ШАГ 5. Как найти пароль?
пароль шифруется КОЯ:
епегур^ес! = 1при( Л кеу
хприТ = епсгургей Л кеу
I
ШАГ 6. Вычисляем пароль:
0x1 А ' 4 0х5А = 0x46 +
0Х0В У 1 0Х5-А ° 0x51 -> Р'
0Х1С ' 1 0x5 А е 0x46 + ’Е*
* 0Х5А = 0X55 -> 'О'
0Х1А ? ' 0Х5А = 0x40 -+
Пароль: "[ЭДЕЦф"
18.4. Уровень 3: более сложный алгоритм
Теперь сгаскте использует не просто ХОК, а комбинацию операций.
Программа на С (исходник):
с
#1пс1ис1е <$иНо.Ь>
#1пс1ис1е <51г1пё,й>
1п1 та1п() {
сНаг 1при^[100];
с^аг соггес!:(] = ,,5есге±123'1;
1П1 ЬазЬ = 9x12345678;
рг1п1-€( "Еп1ег раззыогс!: );
5сап-Е(''%5", 1при1);
1пг гезиИ = 0;
^ог (1пг 1 = 0; 1приЦ1] ’= 0; 1++) {
геаиИ: л= (хпри1:[а2] * вх1Е) + ВхАА;
}
И (гезиИ == ЬазЬ) {
РГ1П1-Р (“ Биссе за! \п ");
} е1зе {
ргхггЕ-Р ( “Ыгопе! \п " ) ;
}
ге(игп О;
}
Ваша задача: Найти пароль (или обойти проверку).
Ъек!
1 АНАЛИЗ СЛОЖНОГО СПАСКМЕ 1 1
Анализ е ЮА:
| ШАГ 1. Загружаем файл * 5Ы^1+Е12 * "5иссез5!н * Е5
| ШАГ 2. Видим код:
1 1 1 1 1 1 1 1 та!п() { | с^аг 1при1[100]; 1П1 ПааЬ = 0x12345678; |
рг1п1?Я( "Еп1ег ра55шогс1: |Н);
5сап^("%5";, 1при1);
1п± гезиН = 0;
•Рог (1П1 1 = 0; 1при1[1] != 0; 1++} {
ге$и1с А= (±при±[1] * 0х1Р) + ЭхаА;
}
И (гезиИ == (135(1) {
рг1п1Р(м5иссе55!\п");
} е1зе {
рг1п1Р("Игоп^1\п ");
}
ШАГ 3, Что делать?
I
* Вариант 1: Найти пароль (сложно, нужно решить уравнение)
• Вариант 2: Обойти проверку (проще)
’ I
Обход проверки:
I-----------------------------------------------------------------1 I
1, найти инструкцию сравнения: стр гезиН, ЬазИ
2. найти условный переход: ^гопн
3. Заменить ^пг на пор (или на 1тр зиссезз)
4, Готово1 проверка обойдена
18.5. Полный алгоритм решения сгаскте
Вот пошаговый алгоритм, который работает для 90% сгаскте.
1:ех^
АЛГОРИТМ РЕШЕНИЯ СЯДСКМЕ
1. ЗАГРУЗИТЬ В ЮА
ЕНе Орел » файл.ехе
Дождаться анализа 1 1
| 2. НАЙТИ СТРОКИ
1 | | 5И1К+Р12 -* найти "5ис«55,1,> "ыгопе"л РаззногсГ Кликнуть по строке -+ прыгнуть в код 1 1 1 1 1
1 3. ДЕКОМПИЛИРОВАТЬ
1 Нажать Е5 * прочитать С-псевдокод 1 1 , 1 1 1
| 4. ОПРЕДЕЛИТЬ ЛОГИКУ
1 1 [ 1 , 1
| | Если (условие) -» $иссе55 Иначе * Шгопе 1 1 1 11 11 1 1 1
1 | 1
| 5. РЕШИТЬ
1 1 1 , 1 1
1 1 1 Вариант А: Найти пароль I 1 1 1 1 11 — 1 1
1 1 1 1. Если пароль в коде + прочитать 2. Если алгоритм простой * вычислить вручную В. Если алгоритм сложный * написать брутфорс 1 1 1 1 1 11 11 1 11 1 1 1
1 1 1 Вариант В: Обойти проверку (патчинг) [ | | 1 1 11 — 1 1
1 1 1 1. Найти условный переход ^2, Зе) 2. Заменить на пор или Зтр 3- Проверить, что работает | 1 : 1 1 1 1 1 1 1 1 11 1 1
1 1 .. 1 1
| 6. ПРОВЕРИТЬ
1 Запустить программу » проверить, что всё работает 1 1 1 1 1
18.6. Практика: решите сгаскте самостоятельно
Теперь ваша очередь!
Задание 1. Решите простой сгаскте
1. Скачайте простой сгаскте (например, с |сгасктез.опе|)
2. Примените алгоритм из этой главы
3. Найдите пароль или обойдите проверку
4. Запишите, сколько времени у вас заняло
Задание 2. Решите сгаскте с ХОК
1. Скачайте сгаскте с ХОК-шифрованием
2. Найдите зашифрованный пароль в коде
3. Восстановите исходный пароль
4. Проверьте, что он работает
Задание 3. Решите сгаскте с обходом
1. Скачайте сгаскте с любой проверкой
2. Вместо поиска пароля — обойдите проверку
3. Используйте патчинг (Кеура^сб или Ес1|1 - Ра1сН ргодгагл)
4. Сохраните патч и проверьте
18.7. Советы по решению сгаскте
±ек!
I-----------------------------------------------------------------------------1
I СОВЕТЫ ПО РЕШЕНИЮ СЙДСКМЕ I
1. ВСЕГДА начинайте со строк
I
Строки - самый быстрый путь к логике проверки.
1----------------------------------------------- 1 I
2* Используйте Е5 (декомпилятор)
I------------------------------------------------------------1 I
не читайте ассемблер - читайте С-псевдокод.
1-----------------------------------1 I
3* Ищите сравнения (стр^.
I-----------------------------------1 I
Сравнение и условный переход - сердце любой проверки, |
1-----------------------------------’ I
4+ Не бойтесь патчить
I-----------------------------------1 I
Иногда проще обойти проверкул чем найти пароль.
II |
5* Используйте отладчик
I-----------------------------------1 I
Если статика не помогла - запустите и посмотрите.
I-----------------------------------1 |
6. Смотрите на размер функции
I-----------------------------------1 I
Если функция маленькая (5-10 строк) - проверка простая|
Если большая - возможно, сложный алгоритм
I______________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
18.8. Карта действий: решение сгаскте
КАРТА ДЕЙСТВИЙ: РЕШЕНИЕ СЯАСКМЕ
СКАЧАТЬ СКАСКМЕ
сгаскте5,опе ! гоо1-те.ог$
2.
ОТКРЫТЬ В ЮА
Г11е -* Орел
3-
НАЙТИ СТРОКИ
5Г11Н+Г12
Найти н5иссе55
т + Дважды кликнуть по строке
4. ПЕРЕЙТИ В КОД
5 + т НАЖАТЬ Р5 -> Прочитать С-псеедокод
6. ▼ понять логику Найти условие проверки
7. т ВЫБРАТЬ ПУТЬ + Найти пароль? или Обойти?
8* т выполнить =+ Прочитать пароль ИЛИ + Заменить 1пг на пор
9- т ПРОВЕРИТЬ -+ Запустить программу
10- т ЗАПИСАТЬ РЕШЕНИЕ Сохранить пароль или патч
~~ Ключевые клавиши: 5МН+Е12 -+ Е5 -» М ; -» Е2 -* Р9
3 Время: 5-60 минут (зависит от сложности)
I I
__________________________________________________________________________
Итоги главы
Сгаскте — учебные задачи для реверс-инжиниринга
Начинайте со строк — 5ЫЛ+Е12 всегда первым делом
Используйте Е5 —декомпилятор упрощает понимание
Два пути — найти пароль или обойти проверку
Уровни сложности — от простого бТгстр до сложной криптографии
Практика — решайте сгаскте регулярно для развития навыков
Поздравляю* Вы прошли все ключевые темы по ЮА Рго. В следующей главе
мы разберём одну из самых востребованных задач — поиск уязвимостей и
исправление багов без исходников*
ГЛАВА 19. Поиск уязвимостей
19.1, Что такое уязвимость и зачем её искать
Уязвимость — это ошибка в программе, которую можно использовать для
нарушения её работы, получения несанкционированного доступа или выполнения
вредоносного кода.
Для анализатора безопасности поиск уязвимостей — одна из ключевых задач, С
помощью ЮА вы можете находить уязвимости даже без исходного кода,
ТехТ
I-----------------------------------------------------------1
ЧТО ТАКОЕ УЯЗВИМОСТЬ
Безопасный код:
I I-------------------------------------------------------------------1
сЪаг* Ьи'Р'Рег[64]д
^8е15(Ьи-Г?ег, бЗ-гео^Ьи-Г-Рег),, еТсИп); * безопасно
I 1-------------------------------------------------------------------1 I
I I
Уязвимый код:
I I-------------------------------------------------------------------1 I
| | сЬаг Ьи^ег[б4]; |
| | Е«5(ЬиН=ег); «- ОПАСНО' |
I__________________________________________________________________I
Последствия уязвимости:
I I-------------------------------------------------------------------1 I
• Переполнение буфера (Ви-ЕТег ОхегПоы)
• Выполнение произвольного кода (ЯСЕ)
• Чтение памяти (ТпТогтаНоп 01$с1озиге)
• Отказ в обслуживании (0о$)
I 1-------------------------------------------------------------------' I
___________________________________________________________________________I
19.2 . Самые опасные функции
Вот список функций, на которые стоит обращать внимание. Если вы видите их в
коде — это красный флаг.
ОПАСНЫЕ ФУНКЦИИ
Работа со строками (без проверки длины):
1 1 1 1 1 1 |_ X X 5*гсру() X з^гсаТО X зргХпТ-РО X 5сапГ(,1%5м) 1 + никогда не используйте - + без проверки размера - + без проверки размера - + без проверки размера + без ограничения длины 1
Безопасные альтернативы:
1 1 1 -+ с ограничением длины
1 з^гпсруО -+ с ограничением длины
1 5^гпсат() + с ограничением длины
1 зпргхп^О -+ с ограничением длины
1 |_ 5СЭП€("%645") -+ с ограничением длины * ।
Другие опасные функции:
1 1 X зуз^ет() 1 -+ может выполнить произвольные команды 1
1 X еиа1() -+ выполнение произвольного кода
1 X тетеру(} -+ без проверки размера
1 X северу(} -+ без проверки размера (МШсо^е)
19.3 . Как найти переполнение буфера
Переполнение буфера — классическая уязвимость. Давайте посмотрим, как её
найти в ЮА.
[ 1 | ПОИСК ПЕРЕПОЛНЕНИЯ БУФЕРА | к
| ШАГ 1. 1 1 Откройте файл в ЮА |
| ШАГ 2. 1 Поищите опасные функции через АН+Т 1
А11+Т + введите "ее!<" или ”5!гсру" или "вргтлМГ’
ШАГ 3, Перейдите к найденной функции
ШАГ 4. Посмотрите на код вокруг
Уязвимый паттерн:
сЬаг Ьи-ЕТег[б4]
| е^1=5(Ьи-Е-Еег); + НЕТ ПРОВЕРКИ ДЛИНЫ! | |
1 1 I
I
Безопасный паттерн:
I---------------------------------------------------------------------------1 I
| сЬаг* Ьи,Р,Рег[64]; | |
| +:§е15(Ьи-РГе1', 51хео,Р(Ьи1Я;ег), з^сЦп); «- ЕСТЬ ПРОВЕРКА! | |
I_________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________I
Пример в ЮА:
сект
Лех!: 00401000 РИ5Ь еЬр
Лех!: 00401001 ШОУ еЬр, еьр
Лех!: 00401003 виЬ евр, 40И ; буфер на 64 байта
Лех!: 00401006 1еа еах, [еЬр-40И]
Лех!:00401009 ризЬ еах
Лех!: 0040100Д са11 §е!з ; *- ОПАСНО!
Лех!: 0040100Р асИ е^р, 4
Лех!: 00401012 ризЬ еах
Лех!: 00401013 са11 ргтп!^
Лех! :0040101В 1еауе
Лех1: М401019 ге!
В Спсевдокоде (Р5):
с
1п1: та4п() {
сбаг ЬиТТег[64];
^е1з(Ьи-Р/ег);
рг1п±^("%з“, Ьи-Р^ег);
ге!игп 0;
// Ч- УЯЗВИМОСТЬ!
19.4 . Поиск уязвимостей форматной строки
Уязвимость форматной строки возникает, когда пользовательский ввод передаётся
напрямую в рппй.
Сех!
I------------------------------------------------------------1
УЯЗВИМОСТЬ ФОРМАТНОЙ СТРОКИ
1 1 Безопасный код:
I 1 рг1п^^("К5и, изегХирцЦ); «- безопасно 1 1 1 1
1 1 Уязвимый код: 1
1 рг1п1Ни5ег_1при1:); I 1 1: * ОПАСНО! | | 1
Как найти в ЮА; 1 1 1
I I I 1. Найти вызов ргз-п!^, ’₽рг,1п1€> зргАп^-Р 2. Посмотреть, что передаётся в качестве первого аргумента! 3. Если это переменная (не константа) -• возможно, уязвимость 1 ] 1
Пример в ЮА; 1 1 , 1
। | . 1 е х*: В0401000 ри $ Н | .Тех! = 00401003 саП 1 1 1 [еЬр+8] ; иаег_1при^ ргхпТ-Р ; ч- ОПАСНО! | | 1 1
1 1 1
19.5 . Как использовать результаты в ЮА
Когда вы нашли уязвимость, важно правильно её задокументировать.
ЬекТ
I--------------------------------------------------------------------------1
ДОКУМЕНТАЦИЯ УЯЗВИМОСТИ
Что. записать:
I---------------------------------------------------------------1 I
| 1. Адрес уязвимого места
2. Тип уязвимости
3. Опасная функция
4. Возможн ы е п ослед с т в и я
5. Рекомендация по исправлению
I I I
Пример:
I---------------------------------------------------------------1 I
# Отчёт об уязвимости
I I I
Файл: уц1легаЫе. ехе
Адрес: В хОВДВ1ВВ А
Функция: ееТв
Тип: Переполнение буфера
Последствия: Возможное выполнение произвольного кода
Исправление: Заменить на ^еХзСЫгРРег, 64, $1(11 л)
1---------------------------------------------------------------» I
19.6. Автоматический поиск уязвимостей (скрипт)
Напишем скрипт для автоматического поиска опасных функций,
техг
I---------------------------------------------------------------------1
| СКРИПТ ДЛЯ ПОИСКА УЯЗВИМОСТЕЙ |
I------------------------------------------------------------------ч
I I
I I-------------------------------------------------------------1 I
хгпрог! 1йаиМ1з
1 трог-Г 1Йзар1
# Список опасных функций
Рапдегоиз-Рклсз = [
| | " 51 г еру", ''з1гсэ1"л ' зргтпТТ", | |
"зсап!", "зузТет”, "тетсру", ''незеру1'
]
рг1п1("=»= Поиск опасных функций
II II
Еог 1Ч1ПС 1п 1с1аиХ 11$ < Гипсе 1оп$():
паше = 1с1аар1,
Гог йап^егои^ 1п йап^егаи$_Гипс5:
1-Г йзпеегои* 1п пзме;
# Находим ссылки на эту функцию
Гог ге-р 1п 1сШШ$. Со^еЯеГ5То(Гипс^ 9):
рг1п1(Т||0пасная функция {папе} 11
Кпо адресу {Ьех(геГ)}1’)
I I I I
рг!п1;(''=== Поиск завершен ===")
I 1-----------------------------------------------------------1 I
I I
Результат:
I I-----------------------------------------------------------1 I
=== Поиск опасных функций ===
Опасная функция _$еТ5 по адресу 0x491004
Опасная функция _5(:гсру по адресу 0x401209
=== Поиск завершён ===
I 1-----------------------------------------------------------' I
I I
I----------------------------------------------------------------1
19.7. Практика: найдите уязвимость в тестовой программе
Задание 1. Найдите переполнение буфера
1. Скачайте тестовую программу с уязвимостью
2. Откройте в ЮА
3. ИсПОЛЬЗуЙТе АК+Т ДЛЯ ПОИСКа ИЛИ зТгсру
4. Перейдите к найденному месту
5. Нажмите Е5 и подтвердите уязвимость
Задание 2. Найдите уязвимость форматной строки
1. Откройте программу в ЮА
2. Найдите вызов рг1пт-г
3. Проверьте, что передаётся в качестве первого аргумента
4. Если это переменная — уязвимость найдена
Задание 3. Создайте отчёт
1. Задокументируйте найденные уязвимости
2. Укажите адреса, типы и рекомендации
3. Сохраните отчёт
19.8. Карта действий; поиск уязвимостей
Ъёк!
Г 1 КАРТА ДЕЙСТВИЙ: ПОИСК УЯЗВИМОСТЕЙ |
1 1 ==^======^===^=======^^^=^====^===^= 1
1 1 1. ЗАГРУЗИТЬ ФАЙЛ В ЮА + ЕНе + Ореп | 1 1 2. ПОИСК ОПАСНЫХ ФУНКЦИЙ + А11+Т + ^5, 31 Геру, ЗрПпТТ | 1 1 3. ПЕРЕЙТИ К ФУНКЦИИ * Дважды кликнуть по результату 1 1 4. ПРОВЕРИТЬ КОНТЕКСТ * Посмотреть, как используется -* Есть ли проверка длины? 1 1
5. (ЕСЛИ НЕТ ПРОВЕРКИ) УЯЗВИМОСТЬ НАЙДЕНА! | уязвимость 1 1 1 6. ЗАДОКУМЕНТИРОВАТЬ * Адрес, тип, рекомендации 1 1 7» (ЕСЛИ НУЖНО) + Использовать отладчик ПРОВЕРИТЬ ЭКСПЛУАТ + Попробовать вызвать переполнение! 1 — — 1
1_ - 1 1 □ Ключевые клавиши: А1Т+Т (поиск) Е5 (декомпиляция) Д ВНИМАНИЕ: Проверяйте уязвимости только в тестовых программах или с разрешения владельца! 1 □
Итоги главы
Уязвимость — ошибка, которую можно использовать для атаки
Опасные функции — деГ5, Ытсру, зрппгЪ зсап^ зуйет
Переполнение буфера — когда данные не помещаются в буфер
Форматная строка — когда пользовательский ввод передаётся в рпп^
Поиск в ЮА — используйте А11+Т для поиска опасных функций
Документирование — записывайте все найденные уязвимости
Теперь вы умеете находить уязвимости! В следующей главе мы научимся
исправлять баги в программах без исходников!
ГЛАВА 20. Исправление багов без исходников
20.1. Когда это нужно
Представьте ситуацию: у вас есть старая программа, которая работает на вашем
предприятии 10 лет. Исходников нет — они потеряны, или компания-разработчик
обанкротилась. Но программа вдруг начала падать или вести себя неправильно,
Что делать? Вы не можете исправить исходный код, потому что его нет. Но вы
можете исправить бинарный файл — с помощью ЮА и патчинга.
КОГДА НУЖЕН ПАТЧИНГ БЕЗ ИСХОДНИКОВ
Ситуации:
I------------------------------------------------------------------1 I
• Старое ПО больше не поддерживается
• Исходники потеряны или недоступны
• Баг проявляется в конкретном месте
• Нужно срочное исправление
[ I___________________________________________________________________I I
I I
НЕ используйте для:
| , |
X Взлома чужих программ
X Обхода лицензий
X Незаконного изменения ПО
| I___________________________________________________________________I |
I I
I_________________________________________________________________________I
20.2, Процесс исправления бага
Исправление бага без исходников — это процесс, похожий на хирургию. Вы
должны точно знать, что меняете.
1 1 | ПРОЦЕСС ИСПРАВЛЕНИЯ БАГА |
1
1 ВОСПРОИЗВЕСТИ БАГ "+ 1 1 Запустить программу
Найти,, что вызывает ошибку
1 2* НАЙТИ МЕСТО В КОДЕ -* Открыть в ЮА
найти место ошибки 1
1 3. ПОНЯТЬ, ПОЧЕМУ ОШИБКА -+ 1 Прочитать код (Р5)
-* Найти причину 1
1 4- ПРИДУМАТЬ ИСПРАВЛЕНИЕ 1 Что нужно изменить? [
1 5. ПРИМЕНИТЬ ПАТЧ -+ 1 Изменить код в ЮА 1
1 ПРОВЕРИТЬ -* 1 Запустить и убедиться 1
1 7. СОХРАНИТЬ 1 Применить патч к файлу 1
1 1 1
203. Пример: программа падает при вводе слишком
длинного текста
Представьте, что у вас есть программа, которая падает, если ввести больше 20
символов.
Исходник (которого у вас нет):
С
#1пс1ис1е <5ЬНо,Ь>
1П1 шатл() {
сНэг пате[2®];
рг1п1^("ЕпТег пате: 11);
5салТ(,,%8"э пате); // * Здесь бог' Нет ограничения длины
рг!пгт("неПо, %з!\п", пате);
геТигп 0;
}
Анализ в ЮА:
Тех!
I--------------------------------------
АНАЛИЗ ОШИБКИ
ШАГ 1. Открываем файл в ЮА
ШАГ 2. 5ЫЕТ+Е12 + находим "ЕпТег пате11
ШАГ 3. Кликаем по строке -+ прыгаем в код
ШАГ 4, Нажимаем Е5 -> видим:
I---------------------------------------------------
1п1: та!п() {
сНаг пате[20];
рг1пТТ("ЕпТег паше: ”);
| БсапТ(и5Й5\ пате); // <- НЕТ ПРОВЕРКИ!
рг1пТ-Е( "НеНо, 5Й5!\п\ пате);
геТигп О;
I }
I___________________________________________________
ПРИЧИНА: зсап-Г(|Г%5") не ограничивает длину ввода
Если пользователь введет 160 символовд произойдёт
переполнение буфера и программа упадёт.
Варианты исправления:
секх
ВАРИАНТЫ ИСПРАВЛЕНИЯ
Вариант 1: Изменить БсалТ на (добавить проверку)
Было:
Лёх!: 0040100Д риаЬ («Ьр-14Ь] ; Ьи-Е-Рег
, ! «Л: 00401000 ри$Н а5 ; "Й5"
500401012 С311 _Есап-Р
Стало (нужно заменить на с ограничением длины):
1ех1:0040100А ривИ 20 ; максимальная длина
Тех1:0040100С ризИ [еЬр-14Ь] ; ЬиТ-^ег
1ех1:0040100Г ривИ о-Г-Гзе! 51с11п
1ех1:00401014 са11
Сложность: ^е15 - другая функция^ с другими аргументами
Потребуется изменить не одну инструкцию.
Вариант 2: Просто ограничить ввод через ^саггР
Было:
ЛехТ:00401000 рызН оН^еТ аБ ;
Стало:
Лех^: 90401000 риаН о€Т$ег аБ2Й ; "36205."
Это просто! Нужно изменить только строку формата,
Вместо ”%5И использовать н%20$'’ - это ограничит ввод 20
символами.
Как применить патч:
гехт
----------------------------------
I ПРИМЕНЕНИЕ ПАТЧА
ШАГ 1. Найдите строку формата |1/с5" в памяти
В окне строк (5МЛ+Р12) найдите "Ез’1
ШАГ 2. Перейдите в Нех УХеи
У1еи Ореп БиРутенБ Нех с!итр
ШАГ 3. Найдите байты строки "Ха"
Адрес: 6x00403000
Байты: 25 73 00 ; "Хз"
ШАГ 4. Измените на ''Х205"
Байты: 25 32 30 73 00 ; "Й205"
ШАГ 5. Сохраните изменения
ЕдИ -* Рэ1с11 ргоегат -* Дрр1у ра^сКеа То 1приТ ТПе...
ШАГ б, проверьте
Запустите программу. Попробуйте ввести 106 символов.
Программа НЕ падает!
20,4. Пример: программа неправильно вычисляет что-то
Представьте, что программа неправильно вычисляет налог — использует 15%
вместо 18%.
Исходник (которого нет):
С
1П1 са1си1аГе_-1ах(1п1 ашоип^) {
геТигп атоипЕ * 15 / // Оы/убко/ Лоджио быть 13
}
Анализ в ЮА:
Ъех1:
г----------------------------------------------------------------1
I ИСПРАВЛЕНИЕ НЕПРАВИЛЬНОЙ КОНСТАНТЫ I
ШАГ 1. Открываем файл в ЮА
ШАГ 2. Находим функцию са1си1а!е_1ах (или бшЬ_...)
ШАГ 3. Нажимаем Е5:
1 1 1пТ ссЛес! са1си1а1е_Тах(1п1 атоипТ) { ге!игп атоип! * 15 / 100; 1 } 1 1 1
в ассемблере:
Г" Лех! = 00401000 ШОУ еах, [еЬр+0] 1 ; амоипТ
Лех! = 00401003 1гпи1 еах,, 15 ; атоигтГ * 15
Лех! :0040100б сс1д 1
Лех! :00401007 ШОУ есх, 1ЭЭ 1
Лех! :0040100С 1с11у есх ; / 100 |
ь Лех! :0040100Е гет 1 1
Что нужно изменить: 15 *+ 10
Инструкция: 1ти1 еах, 15
Байты: 6В СО ЭЕ ; 1ти1 еах, 15
(ЭЕ = 15 в шестнадцатеричной)
ШАГ 4, изменяем 15 -* 18
Было: 66 СО СЕ
Стало: 6В СО 12 12 = 13 в шестнадцатеричной
ШАГ 5. Применяем патч
Е(И1 + РаТсИ ргоегат ч СНап^е Ьу1е
Адр е с: 0x00401003
Новое значение: 0x12
20.5. Пример: программа выводит неправильное сообщение
Иногда нужно просто изменить текст сообщения.
гех*
I----
ИЗМЕНЕНИЕ ТЕКСТА
Ситуация: Программа выводит "Еггог 404м вместо более
понятного сообщения,
В ЮА:
1 | Лех!: 00401020 ри$Н о-г-Рзе* аЕггог404 I ; "Еггог 404" I
| Лех*=00401025 1 саН _рг1п1:’Я I г
ШАГ 1. 5ИШ+Е12 -> найти "Еггог 404" ШАГ 2. Перейти в Нех Утен
ШАГ 3. Изменить Было: 45 72 72 текст 6Р 72 20 34 30 34 00 ; "Еггог 404"
Стало: 46 69 6С 65 20 6Е 6Р 74 20 66 ; иЕ11е по* €
6Е 75 6Е 64 00 ; "сшгмГ
Результат: "ЕНе по1 ТоипсГ
I I
ВНИМАНИЕ: Длина новой строки ДОЛЖНА совпадать с длиной
старой! если не совпадает - программа упадёт.
I I
Обход:
* Делайте строку такой же длины
* Или добавьте пробелы в конце
• Или используйте другой адрес для хранения строки
I I
I__________________________________________________________________________I
20.6. Инструменты для патчинга
Вот инструменты, которые помогут вам патчить программы.
Сех!
1 1 ИНСТРУМЕНТЫ ДЛЯ ПАТЧИНГА |
1 ' В ЮА: 1
1 | ЕсИТ -> РаТсК рго^гаш + Д5 5етЫе * изменить 1 1 инструкцию
| ЕсИТ -» РаТсЬ рга^га-п + Сбап^е Ьу1е * изменить байт
ЕсШ + Ра1сИ рго^гат + Арр1у ра^сЪез * сохранить в файл
I______________________________________________________________I
Кеура^сЬ (плагин):
I--------------------------------------------------------------1
ССГ1+АК+К + изменить инструкцию
С1:г1+АИ+Р -> показать все патчи
I______________________________________________________________I
Вне ЮА:
I--------------------------------------------------------------।
хб4с!Ь§ / х32с!Ь§ + отладчик с возможностью патчинга
Н1ен -» Ьех-редактор для патчинга
Епяхпе * поиск и изменение данных
I_______________________________________________________________I
20.7. Практика: исправьте ошибку в программе
Задание 1. Исправьте переполнение буфера
1. Скачайте тестовую программу с переполнением буфера
2. Откройте в ЮА
3. Найдите место ошибки (дек, 5(гсру)
4. Измените форматную строку, чтобы ограничить ввод
5. Проверьте, что ошибка исправлена
Задание 2. Исправьте неправильную константу
1. Скачайте программу с неправильной константой
2. Откройте в ЮА
3. Найдите инструкцию с константой
4. Измените её на правильное значение
5. Проверьте, что программа считает правильно
Задание 3. Измените текст сообщения
1. Скачайте программу с любым текстом
2. Откройте в ЮА
3. Найдите текст в окне строк
4. Измените его на другой (той же длины)
5. Проверьте, что текст изменился
20.8, Карта действий: исправление бага без исходников
I---------------------------------------------------------------------------1
I КАРТА действий: ИСПРАВЛЕНИЕ БАГА I
1, ВОСПРОИЗВЕСТИ БАГ 1 + Запустить программу
Найти^ что вызывает ошибку
т
2. ОТКРЫТЬ В ЮА 1 т -+ ЕНе + Орон-
3. НАЙТИ МЕСТО ОШИБКИ 1 1 т -+ По строкам ($Ы-РЪ4-Р12) Или по функции
4* ПОНЯТЬ, В ЧЁМ ОШИБКА 1 1 т + -* Нажать Е5 Прочитать код
5. ПРИДУМАТЬ ИСПРАВЛЕНИЕ 1 1 1 т -+ -э -+ что изменить? Константу? Инструкцию? Строку?
6. ПРИМЕНИТЬ ПАТЧ 1 1 1 т * АвеетЫе (С1Г1+А11+А) | СКап^е Ьу1:е Изменить строку
7. ПРОВЕРИТЬ 1 1 т -+ -* Запустить программу Баг исчез?
8„ (ЕСЛИ ВСЁ РАБОТАЕТ) ЕсН1 + Ра1гсТ1 рго^гагп +
СОХРАНИТЬ ПАТЧ Арр1у ра1сЬе5 1о тпри! ТЧ.1е
Совет: Всегда тестируйте патч перед сохранением!
Д ВНИМАНИЕ: Сохраняйте бэкап исходного файла!
20.9. Дополнительные советы
Вот несколько полезных советов для исправления багов.
Тех!
Г--------------------------------------------------------1
ДОПОЛНИТЕЛЬНЫЕ СОВЕТЫ
1 1 1. Всегда делайте бэкап
1 1 Копируйте исходный файл перед любыми изменениями. 1 1
| 2. Тестируйте на виртуальной машине
1 1 Если программа критичная - тестируйте патч в УМ. 1 1 |
1 1 3. Используйте отладчик для проверки
1 1 Запустите под отладчиком и убедитесь^ что патч работает правильно. 1 1
4. Документируйте изменения 1 , , I
1 1 |. 1 Записывайте, что, где и почему вы изменили.
Это поможет позже. 1 1 |
5. Если патч не работает - откатывайтесь
1 1 Восстановите бэкап и попробуйте другой подход. 1 I
1 1 1 1
Итоги главы
Исправление багов без исходников — реальная задача
Процесс: воспроизвести — найти — понять — исправить — проверить — сохранить
Патчинг— изменение кода или данных в бинарном файле
Изменение строки — самый простой патч
Изменение константы — часто встречается
Изменение инструкции — сложнее, но мощнее
Тестирование — критически важно перед сохранением
Бэкап — всегда сохраняйте оригинал
Поздравляю! Вы освоили все основные темы по ЮА Рго! В следующей главе
мы подведём итоги и посмотрим, куда двигаться дальше.
ПРИЛОЖЕНИЕ А. Ассемблер для чайников (ЮА Рго-
версия)
А.1. Зачем вам ассемблер, если есть Е5?
Хороший вопрос! Е5 (декомпилятор) делает 90% работы за вас. Но в 10% случаев
ассемблер всё равно нужен:
Р5 не работает (у вас ЮА Ргее)
Декомпилятор выдаёт странный код (иногда ошибается)
Вы работаете с экзотической архитектурой
Нужно понять, что именно происходит 4под капотом"
Вы хотите стать настоящим профи
В этом приложении мы не будем изучать ассемблер как язык
программирования. Мы научимся узнавать его в ЮА и понимать основные
паттерны.
А.2. Как выглядит ассемблер в ЮА
Вот так выглядит типичный код в ЮА:
1ех1
г~-------------—-----------------------------------------------1
I АССЕМБЛЕР & ЮА РАО I
16X1:00401000 ри&И еЬр ; сохраняем старый еЬр
16X1:00401001 тоу еЬр, еьр создаём стековый фрейм
1ех1:00401003 зиЬ 65р, 1011 ; выделяем 16 байт
16X1:00401006 тоу еах, [еЬр+8] ; загружаем аргумент
Лех! =00401009 ризИ еах ; передаём в функцию
Лех! =0040100А са11 _51г1еп ; вызываем 51г1еп
Лех! = 0040106 Е езр, 4 ; очищаем стек
Л ех! = 00401012 стр еах, 5 ; сравниваем с 5
лех! =00401015 1П2 зИог! 1а11 ; если не 5 + ошибка
л ех!: 00401017 ризЬ оГ^е1: аБесгег ; "зесге*"
Л ех1: 0040101С ризН [еьр+е] аргумент
Лех! = 0040101Р С311 _з1гстр ; сравниваем
Лех! =00401024 а^с! 65р, 8 ; очищаем стек
Лех! =00401027 165-1 еах,, еах ; проверяем результат
Лех! =60461029 }пг 5Иог1 1аИ ; если не 0 -* ошибка
Лех1:0040102В тоу еах, 1 ; успех * возвращаем 1
Л6x1:00401030 Лех! =00401032 Зтр 1а11: 5Иог1 епсЗ ; прыгаем в конец
Л6X1=00401032 Л6X1=00401034 хог епа: еах, еах ; ошибка -* возвращаем
Лех! =00401034 Хеауе ; восстанавливаем стек
Лех1=00401035 ге! ; возвращаемся
Что означают колонки:
Колонка
Что это
Лех!: 00461000
ризЬ еЬр
; сохраняем...
Адрес в памяти
Инструкция
Комментарий (добавлен вами или ЮА)
А.З. Регистры — "карманы" процессора
Это самое важное! Регистры — это ячейки внутри процессора, где хранятся числа.
1ех1
Г-----------------------------------------------------------------------1
I РЕГИСТРЫ В ЮА I
32-битные (х86):
ЕАХ -» главный регистр (результат возвращается сюда)
ЕВХ + дополнительный
ЕСХ + счётчик (для циклов}
ЕОХ + дополнительный
Е51 источник (зоигсе 1пс1ех)
Е01 -* приёмник {С1е5^±па-С 1ои 1пс1ех)
ЕВР -> основание стека (базовый указатель)
Е5Р -» вершина стека (указатель стека)
Е1Р -> счётчик команд (куда смотреть!)
В ЮА вы видите их в окне Яе^151егз:
ЕАХ = 0000000А
I ЕВХ = 00403000
I ЕСХ = 00000005
I Е1Р = 00401003 «- СЮДА СМОТРИТЕ!
Для 64“битных (х64) регистры называются ВАХ, НВХ^ НСХ...
Что нужно запомнить:
1. ЕАХ — сюда функция кладёт результат Если после с а 11 вы смотрите на ЕАХ — еы
видите, что вернула функция.
2. Е1Р — показывает, на какой инструкции программа сейчас находится. В отладчике
это текущая позиция.
3. Е5Р — вершина стека. Не трогайте его без необходимости.
4. ЕВР — основание стека. Используется для доступа к аргументам и локальным
переменным.
А.4. Самые частые инструкции (15 штук!)
Вот 15 инструкций, которые покрывают 90% кода в ЮА. Остальное можно гуглить.
<ех1:
Г--------------------------------------------------------------1
ТОП-15 ИНСТРУКЦИЙ
1, шоу -+ переместить денные
тоу еах, 5 -» ЕАХ = 5
шоу еах, [еЬр+Я] + ЕАХ. = значение по адресу еЬр+8 1 1
ШОУ 1 [еЬх‘ л еах + *ЕВХ = ЕАХ (записать по адресу) 1 1 1 1
2. ри$И -> положить на стек 1 1 1 , 1
1 ризК еах -> стек. ри$Г| (еах) 1 1 1 1
| ри$К 1 5 + стек.рц511(5) 1 1 1 1
3* рор + снять со стека 1 1 1 . 1
1 1 рор 1 еах =* еах = стек^рорО 1 1 1 1 ] 1
4. са11 -+ вызвать функцию 1 1 1 , 1
г- | сэ11 зЪгстр -+ перейти на функцию _з1гстр 1 1 1
| са11 1 еах + перейти по адресу в ЕАХ 1 1 1 1
5. ге± + вернуться из функции 1 1 1 1
1 гег вернуться 1 1 1 1
| ге^ 1 8 -• вернуться и очистить 8 байт 1 1
6. айй сложить 1 1 1 , 1
1 | ас1с1 1 еах, 5 * ЕАХ = ЕАХ + Б 1 1 1 1 1 1
7. ЗчЬ -+ вычесть 1 1 1 , 1
1 I е$р, 10И + Е5Р = Е5Р - 16 (выделить место) 1 1 1 1 1 1
3- стр -+ сравнить (устанавливает флаги) 1 1 1 , 1
1 1 стр 1 еах, 5 * сравнить ЕАХ и 5 1 1 1 1 1 1
9. ^е$1 1 -+ сравнить с нулём (устанавливает флаги) 1 1 1 —1 1
1ев1 еах, еах * проверить ЕАХ на 0 1 1 1 —1 1 1
10. }тр -» безусловный переход
1 1тр 1аЬе1 I -» прыгнуть на 1аЬе1 1 1 1 1 1 1 1
11. ди / ]е + переход, если равно 1
1 стр еах, ]е 1аЬе1 । 5 + если ЕАХ == 5 -+ прыгнуть 1 1 1 1 1 1 1 1 г
12, Зпз / ]пе -* переход, если не равно 1 1
1 стр еах, | ]П2 1аЬе1 5 -> если ЕАХ ! = 5 + прыгнуть 1 1 1 1 1 1
13. з'е / Де + переход^ если больше / меньше 1 1
( — стр еах, | 1аЬе1 1 5 -* если ЕАХ > 5 -» прыгнуть 1 1 1 1 1 1 1 1 1 1
14. хог -* исключающее ИЛИ (часто для обнуления) 1 1
хог еах, । еах + ЕАХ = О (быстрый способ обнулить) 1 1 1 1 1 1
15. пор + ничего не делать 1 1
1 пор -» 1 пустышка (используется для патчинга) 1 1 1 1 1 1 1
А.5. Что означает [еЬр+8] и другие странные вещи
В ЮА вы часто видите [еЬр+8], [еБр+д], [еах] и т.д. Это обращение к памяти по
адресу.
гехг
---------------------------------------------------------------------------------
| ЧТО ЗНАЧАТ СКОБКИ |
I-----------------------------------------------------------------------------1
I I
шоу еах, [еЬр+8]
I ------------------------------------------------------------------------- I
"Возьми значение по адресу (еЬр + 8) и положи в ЕАХ"
I I
| еах = *((1п1:*)(еЬр + 8)); |
<поу [еЬх], еах
I ------------------------------------------------------------------------- I
"Возьми значение из ЕАХ и запиши по адресу (еЬх)”
I I
*еЬх = еах;
I I
| 1еа еах, [еЬр-10Р]
I ------------------------------------------------------------------------- I
'"Загрузи адрес (не значение!)*1
I I
еах = еЬр - 16; // Указатель на локальную переменную
I I
I_____________________________________________________________________________I
Запомните:
Запись Что значит С-эквивалент
[еЬр+е] Читаем по адресу *(1п,Ь*)(еЬр+8)
[еах] Читаем по адресу в ЕАХ *еах
[еЬх+4] Читаем по адресу + 4 (еЬх+4)
[евт+есх] Сложный адрес *(1пТ*)(е51+есх)
А.6. Стек — что это и как он выглядит в ЮА
Стек — это область памяти, где хранятся временные данные. Он растёт вниз (к
меньшим адресам).
сехт
СТЕК е ЮА
До вызова функции:
1 | Е5Р - 0О12РР00 | 1 —I I 1
После ризИ аргументов:
1 | 0012ЕЕ00 | | 0012ЕЕЕС | 1 1 | аг§2 = 5 * Е5Р | 1 1 1 1
После са11 (адрес возврата):
г | 0012ЕЕ00 | | 0012РЕГС | | 0012ЕЕЕ8 | 1 1 ••• | аге2 = 5 ге1:игп аск)ге55 «- Е5Р 1 1 1 1
Внутри функции (ЕВР = основание):
I | 0012РЕ0О | 1 1
| 0012РЕЕС | аге2 = 5 * [ЕВР+8] 1 1
| 0012РЕЕ8 | ге1:игп
| 0012РЕР4 | о1Й ЕВР «- ЕВР ||
| 0012РЕЕ0 | 1оса1 уаг + [ЕВР-4]
| 0012ЕЕЕС | 1оса1 уаг * [ЕВР-8]
| 0012ЕЕЕ8 | 1 * Е5Р || 1
В ЮА вы видите стек в окне 51аск
1 Аййгезв 1 Уа1ие |
1 0012РЕРС 00000005 -> аг^2 |
1 0012ЕЕЕ8 00401050 -> геТыгп асИге55
| 0612ЕЕЕ4 0012ЕЕ00 -+ оЮ ЕВР |
| 0612ЕЕЕ0 1 00000000 + 1оса1 уаг 1
Как читать стек в ЮА:
Выше ЕВР — аргументы функции (1ЕВР+8], [ЕВР+12]..-)
Ниже ЕВР — локальные переменные ([ЕВР-4], [ЕВР-8]...)
В Е5Р — вершина стека (то, что добавлено последним)
А.7. Как выглядит вызов функции в ЮА
Вот стандартный паттерн вызова функции.
сект
1 ВЫЗОВ ФУНКЦИИ 1 1
До вызова (подготовка): 1 1
1 1 1 1 1 1 ри$И аге2 ; передаём 2-й аргумент ри$И аге1 ; передаём 1-й аргумент са11 _5*1*стр ; вызываем функция асШ евр, 3 ; очищаем стек (снимаем аргументы) 1 1 1 1 1 1 1 1 1 —1 1 1 1 1 1 1 1 1
Внутри функции (пролог):
I 1 1 1 1 1 1 1 1 1 1 ри$И еЬр ; сохраняем старый ЕВР шоу еЬр^ езр ; создаём стековый фрейм зиЬ &5р, 20Н , выделяем место для локальных | 1 1 1 1 1 1 1 —1
Внутри функции (доступ к аргументам):
1 1 1 1 1 1 1 1 1 шоу еах., [еЬр+8] ; читаем 1-й аргумент тоу еЬх, [еЬр+12] ; читаем 2-й аргумент 1 1 1 1 1
Внутри функции (локальные переменные):
1 1 1 1 1 1 1 1 1 шоу [еЬр-4], в ; локальная переменная шоу [еЬр-8], 10 ; ещё одна 1 1 1 —1
Выход из функции (эпилог):
1 1 1 1 I 1 1 шоу еах, геьиК ; результат в ЕАХ 1еауё ; восстанавливаем стек 1
; возвращаемся
к
Что запомнить:
1. Аргументы передаются через стек (ризЬ)
2. Результат возвращается в ЕАХ
3. Пролог функции: риай еЬр; тоу еЬр, егр; $иЬ е$р, ...
4. Эпилог функции: 1<?ауе; геТ
А.8. Как выглядит условие (И) в ЮА
В С: И= (х == 5) { ... } е1зе { ... }
В ЮА:
1 1 | УСЛОВИЕ В ЮА |
| Лехг:00401009 | Лех1: 00401003 | Л е х1:: 00401006 | Лех*: 00401008 1 Лех*:00401008 | Лех1:90401000 | Лех1:00401012 | Лех!: 90491917 | Лех*: 99491917 | Лех*: 90491017 | Лех*:0940101С | Лех* :00401021 | Лех*: 00491021 [йоу еах* [еЬр+8] ; стр еах* 5 ; Зпз е15е_1аЬе1 ; ; ТЕЛО I? рызК о^5е* аЕс|иа1 ; саП _рг1п*^ ^тр епс!_1аЬе1 ; е15е_1аЬе1: ; ТЕЛО Е1&Е риаН с^Тге* а№*Едиа1 саП _рг!п** епй_1аЬе1: ; ДАЛЬШЕ 1 ' загружаем х сравниваем с 5 если не 5 -+ е1$е 1 "х == 5" | 1 конец 1Г 1 1 ; "х != 5" | 1 1 1 |
В С-псевдокоде (Г5): 1 1 , 1
г 1 I 1Т (X == 5) | | ргтпТГС 1 1 } е!$е { 1 1 ргЛпт^С 1 1 > { х п= 5"); X != 5"); 1 1 1 1 1 1 1 1 1 1 1 1
Условные переходы в ЮА:
Инструкция Условие
Если равно (2его)
}пг / Зпе Если не равно (Ыо12его)
3& Если больше (бгеа^ег)
эее Если больше или равно
11 Если меньше (Ье5$)
31е Если меньше или равно
1а Если выше (беззнаковое)
1Ь Если ниже (беззнаковое)
А.9. Как выглядит цикл (йэг) в ЮА
В С:-Гог (±п* 1 = 0; ± < 10; 1++) { ... }
В ЮА:
1ехт
I цикл 1 0 ЮА |
| Лех*:00401000 ШОУ [еЬр-4]!> О ; 1 = О
| Лех*:00401007 1гпр сИеск_1оор
| Лех*=00401000 1оор_Ьос1у:
| Л0x1:0040100с ; ТЕЛО ЦИКЛА
| .10X1:00401000 той еах, [еЬр-4]
| Лех*:0040100Е асШ еах, 1
| Лех* = 00401012 той [еЬр-4], еах ; 1++
| Лех*: 00401019 сИеск_1оор:
Лех1:00491019 стр [еЬр-4], 10 ; 1 < 10?
Лех!:00491020 ]1 1оор_Ьос1у ; да + цикл
Лех1:00401026 ; КОНЕЦ ЦИКЛА
В С-псевдокоде (Е5):
I----------------------------------------------
I -Рог (хп<: 1 = 0; I < 10; 1++) {
// тела цикла
I____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________I
А. 10. Ассемблер АЙМ для тех, кто работает с мобилками
Если вы работаете с Апдго!с1 или Ю5Г вам встретится АКМ-ассемблер.
1=ех±
I-------------------------------------------------------------------------1
I АКМ-АССЕМБЛЕР В ЮА I
Отличия от х8б:
г | х86: 1 аргументы + стек
| АРМ: аргументы + регистры К0, Р1^ Й2, РЗ
х8б: результат * ЕАХ
| АРМ: результат * К0
| х86: вызов * са!1
| АРМ: вывов + Ь1 (ЬгапсН ыИН Ипк)
| х8б: возврат -+ ге1:
| АРМ: возврат + Ьх 1г
Пример АРМ-функции:
I--------------------------------------------------------------1 I
; 1П1 СКескРазэшгЦ(соп51 сНаг* хпри!)
; 1при1 =+ Р0
РУ5Н {гМ, 1Г} ; сохраняем регистры
тоу г4, г0 ; сохраняем хпри! е г-4
1<1г г1, =а5есге! ; загружаем “$есге^н
ШОУ г9, г4 ; зпри! в К0
Ы 51гстр ; вызываем 51гсгар
стр г©, #3 ; сравниваем результат с 0 Ьец еиссез5 если 0 + успех тоу гО, #0 ; ге1игп Э рор {г4? рс} ; возврат зиссезв: мо^ г0, #1 ; ге-Ьигп 1 | рор {г4, рс} ; возврат 1 1
Основные АРМ-инструкции: 1 1
1 1 шоу + переместить 10г + загрузить из памяти (1оа0) г + сохранить в память (зюге) 3(10 -+ сложить $иЬ + вычесть стр -+ сравнить Ь -+ безусловный переход (Ьгапс11) Ьец + переход, если равно Ьле + переход, если не равно Ь1 + вызов функции Ьх 1г + возврат 1 1 1 1 1 1 1 1 1 1 1 1 1
I-------------------------------------------------------------------1
А.11. Шпаргалка: частые паттерны
Вот типичные паттерны, которые вы увидите в ЮА.
сект
I-------------------------------------------------------------------1
| ЧАСТЫЕ ПАТТЕРНЫ |
I-------------------------------------------------------------------1
I I
1, Обнуление регистра
хог еах^ еах + ЕАХ = 0
I I
2. Проверка на ШИ
тегг еах, еах
]2 еггог -* 1Т (еах == в) ^аТо еггог
I I
3» Сравнение с константой
стр еах, 5
]е 1эЬе1
+ И (еах = 5) §010 1аЬе1
4. Вызов функции и проверка результата
саП _51гстр
ге$г еах, еах
1г $иссе« -> 1Т (игсшр(..== Э) §01 о гиссегз
I
5. Цикл с счётчиком
хог есх, есх + 1 = 0
1оор_51аг1:
; тело цикла
1пс есх * 1++
стр есх, 10
11 1оор_пагс + И (1 < 10) яою 1оор_^аг^
I
б+ копирование строки
ризИ зоитсе
ризИ йей
саП _зТгсру * з1гсру(с1е51Л зоигсе)
асМ езр^ 8
АЛ 2. Как читать ассемблер в ЮА: пошаговый алгоритм
Вот алгоритм,, который поможет вам разобраться в любом участке кода.
I----------------------------------------------------------------------------1
I КАК ЧИТАТЬ АССЕМБЛЕР I
ШАГ 1. Найти начало функции (пролог)
I-------------------------------
ризЬ еЬр
шоу еЬр., езр
5иЬ езр, 20Н
-* Это нвчало. Дальше - логика,
I
ШАГ 2. Найти аргументы (доступ к [еЬр+8])
I-------------------------------------------------------------1 I
шоу еах., [еЬр+8]| + 1-й аргумент
шоу еЬх, [еЬр+12] + 2-й аргумент
ШАГ 3. Найти логику (условия> циклы, вызовы)
стр еах, 5 -> сравнение
1пх 1аЬе1 -* условие
саП _5*Г*СПЯр -» вызов
ШАГ 4. Найти возврат
шоу еах, гезиИ + результат в ЕАХ
1еа^е + эпилог
ге^ + возврат
Итоги приложения
Ассемблер в ЮА выглядит иначе, чем в учебниках
Регистры — ЕАХ (результат), Е1Р (текущая инструкция)
15 инструкций покрывают 90% кода
Стек — (ЕВР+8] = аргументы, [ЕВР-4] = локальные переменные
Условия —стр + ]г/]пт/)д/)1
Циклы — стр +_|1/)д
АРМ — аргументы в КО-КЗ, результат в КО
Главное правило — не пытайтесь выучить всё. Узнавайте паттерны!
Теперь вы можете читать ассемблер в ЮА!
ПРИЛОЖЕНИЕ Б. Горячие клавиши — шпаргалка
Б.1. Самые важные (запомните их в первую очередь!)
Этот минимум нужно выучить наизусть. Остальное можно подсматривать.
I--------------------------------------------------------1
ТОП-10 ГОРЯЧИХ КЛАВИШ
Е5 * ДЕКОМПИЛЯЦИЯ Превращает ассемблер в С-псевдокод * САМАЯ ВАЖНАЯ КЛАВИША ★ | 1
| 5П1П+Р12 1 -+ окно СТРОК | Показывает все текстовые строки в программе ★ ВТОРАЯ ПО ВАЖНОСТИ ★ |
1 х * ПЕРЕКРЁСТНЫЕ ССЫЛКИ | Показывает, кто вызывает эту функцию/строку 1
1 М 1 * ПЕРЕИМЕНОВАТЬ | Дать новое имя функции, переменной или метке |
1 -+ КОММЕНТАРИЙ | Добавить комментарий к строке 1
1 с 1 * ПЕРЕЙТИ К АДРЕСУ | Перейти к конкретному адресу или функции 1
Ебс 1 * НАЗАД | Вернуться к предыдущему месту (как васк в браузере)!
Пробел -> ПЕРЕКЛЮЧИТЬ РЕЖИМ | Текст -» Граф / Граф -» Текст 1
1 р2 1 -» БРЕЙКПОИНТ | Поставить или убрать точку останова 1
1 1 -* ЗАПУСТИТЬ ОТЛАДКУ | Запустить программу под отладчиком 1 =^=^=^=__=__=__ |
Б.2. Навигация
Клавиши для перемещения по коду.
их*
НАВИГАЦИЯ
1 с + 1 Перейти к адресу или имени
1 Егс => Вернуться назад
С1г'1+ЕгтЬег -+ Перейти вперёд (после Ебс)
| аги -> Показать точки входа (Еп1гу Рохгтсз)
| А1т+ир -+ Перейти к предцдущей функции
АК+Ооып -+ Перейти к следующей функции
| С1Г1+Е + Найти в текущем окне
| А11+Т -+ Поиск текста по всей программе
| А11+В + Поиск бантов (последовательности)
СЕгТ+Ра^еир -* На 100 строк вверх
С1г1+РЭйеОошп-* 1 На 100 строк вниз 1 1
Б.З. Работа с кодом
^еж±
1 1 | РАБОТА С КОДОМ |
1 + 11 Декомпилировать (ассемблер * С)
Пробел Переключить текст/граф
ТаЬ + Переключить представление (синхронизировать)
ЕпТег => Перейти по вызову (са11) или ссылке
1 к -> Переименовать функцию/переменную
-+ Добавить комментарий
1 у -+ Задать тип переменной
1 н -+ Показать в шестнадцатеричном виде
1 <2 * Показать в десятичном виде
1 в -* Показать в двоичном виде
* 1 + Добавить комментарий к функции 1 1
Б. 4. Работа со строками и данными
СТРОКИ И ДАННЫЕ
5ЫП+Е12 Открыть окно строк (Б1г1пд5 Шпскш)
| С1Г1+Е * Поиск в окне строк
1 А -> Определить как строку (Д8СП)
1 и * Определить как ип1сас1е
1 0 Определить как данные (байт/слово/двойное слово) |
1 с - 1 1 Определить как код (инструкция) 1 1
Б. 5. Отладка
гехт
1 к ОТЛАДКА
1 1 | Е9 + 1 1 Запустить / Продолжить (Нил)
| Е8 -> Шаг с обходом (51ер Оуен)
1 р7 * Шаг с заходом (51ер 1п1о)
| С1Г1+Е7 + Шаг с выходом (51ер Ои±>
| Г2 + Брейкпоинт (Тодв1е)
| А1Т+Е2 * Остановить отладку
| Е4 - Выполнить до курсора
| С1Г1+Е2 + 1 1 Перезапустить отладку 1 1
Б.6. Патчинг
^ехТ
1 1 ПАТЧИНГ
1 1 | С1г1+А11:+А -* 1 1 ДазетЫе (изменить инструкцию)
| С1Г1+А11+К * Кеура'ЁсИ (АззетЫе с плагином)
| С1Г1+А11+Р + 1 1 Показать все патчи (КеураГсН) 1 1
Б.7. Виды и окна
ВИДЫ И ОКНА
| 5ЬЖ+Е1 * 1 1 Окно типов (1оса1 Туреа)
| 5Н1Л+Р2 + Окно меток (1_аЬе1ь)
| ВКШ+ЕЗ * Окно имен (Матеь)
| 5Н1П+Е4 * Окно структур (51гис1ыге5)
| С1Г1+Е Окно функций (ЕшчсНопб)
СТгТ+ЗЫН+Е-» 1 Окно функций (поиск) 1 1
Б.8. Шпаргалка для печати (одна страница)
Вот минимальная шпаргалка, которую можно распечатать и держать перед
глазами.
!г 1 ЮА РКО - ШПАРГАЛКА и 1
1 р5 * Декомпиляция (ассемблер * С) ★
| 5Н1Л+Е12 + Строки ★ II
| X -> Перекрёстные ссылки * II
|] М + Переименовать * II
-> Комментарий * и
1 $ =* Перейти к адресу * и
1 Е5С -+ Назад * II
Пробел -+ Текст / Граф * II
1 р2 -+ Брейкпоинт * я
1 р9 -+ Запустить отладку * 0 II
ЕпТег + Перейти по вызову 1
0 у -+ Задать тип II
В Д11+Т + Поиск текста по всей программе II
В ССГ1+Е Точки входа II
В ЕВ -+ Шаг с обходом II
1 р? + Шаг с заходом II
| СШ+АИ+А -+ АззетЫе (патчинг) II
| «Г14А11+К + Кеура1:сК (патчинг) II
Итоги приложения
> 10 клавиш покрывают 90% работы
• Р5 — самая важная (декомпиляция)
• 5ЫН+Н2 — вторая по важности (строки)
• Е5С — всегда возвращает назад
• Распечатайте шпаргалку и держите перед глазами
ПРИЛОЖЕНИЕ В. Таблица системных вызовов (Штс1ош$
Ыпих)
ВЛ. ОТтс1оуу5 АР1 (самые частые)
Вот функции \Мпс1от, которые вы чаще всего встретите в ЮА.
1 1 | Н1М00И5 АР1 (кегпе!32) |
Работа с файлами:
1 | [ СгеаТеЕНеА/Ы , 1 1 открыть файл
Кеа^ЕИе + читать из файла
№йеИ1е + писать в файл
С1о5еНапс11е + закрыть дескриптор
| | ОеХеТеЕНеА/Ш -+ удалить файл
| | момеРПед/ы 1 -+ переместить/переименовать файл [ |
Работа с памятью: 1
I ! | | У1г1иа1А11ос "+ 1 1 вщделить память
71г1иа1Егее + освободить память
НеарАПос + выделить в куче
неарЕгее 1 освободить в куче ' 1
Работа с процессами:
СгеаГеРгосевзА/к + создать новый процесс
ОрепРгосезз + открыть существующий процесс
ТегтпзГеРгосезз * завершить процесс
<Зе^Сиггеп1:Ргосе55-* получить текущий процесс
Работа с реестром:
I----------------------------------------------------------------1 I
Ке^ОрепКеуЕхА/к * открыть ключ реестра
КеЁОиегуУа1иеЕхА/кН прочитать значение
Кеё&еГУа1оеЕкА/К -* записать значение
КееС1озеКеу + закрыть ключ
I____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________I
сект
1 1 | Ы1МООИ5 АР1 (иаегзг) |
Окна и сообщения; 1 1 1
1 Сгеа^еШпРоыЕхАЛ! -* 1 1 создать окно
5!НомИз.пс1ош -> показать/скрыть окно
<3е ГН 1 пйоыТ е х! А/ к -» получить текст окна
| | 5еЕк1п^оиТех1А/к -> установить текст окна
Ме5Еа§еВохА/к ч показать сообщение
5еп<1МеЕБа&еА/Ы ч отправить сообщение
бе1МеЕ5а§еА/к ч получить сообщение
01зраЕсЬМе БЗ^еА/И-* 1 1 обработать сообщение 1 |
Ввод: 1 1 1 1
1 беГАзупсКеуБГаГе -> 1 1 проверить клавишу
| | беЕКеуБЕаГе ч получить состояние клавиши
СеГСигЕОгРоЕ ч получить позицию курсора
ЗеГСпгЕОгРоЕ ч | | установить позицию курсора 1 |
1 1
Ы1МСЮН5 АР1 (из2_32) - сеть
Сокеты:
I----------------------------------------------------------------------1
ьоске!: -+ создать сокет
соппес! -+ подключиться к серверу
Ыпс( "+ привязать к порту
1151еп + начать прослушивание
ассер! + принять соединение
56 ПС1 4 отправить данные
несу -+ получить данные
сХозезоскес -+ закрыть сокет
В.2. Ьтих $у$са115 (самые частые)
В 1.1пих функции вызываются через зузсаНх (номера).
I------------------------------------------------
ИШХ 5У5СД115 (х8&_&4)
Номер Имя 1 Описание 1
'0 1 геас! читать из файла
1 шгПе писать в файл
2 ореп открыть файл
3 с1ояе закрыть файл
4 | 51а1 получить информацию о файле
5 ^5^31 получить информацию о дескрипторе
6 15^31 получить информацию о ссылке
9 тар отобразить файл в память
11 ехесуе выполнить программу
39 | е^1=р1с1 получить РЮ
56 с1опе создать поток (^огк)
59 ехесуе выполнить программу
60 ехП завершить процесс
63 получить 1Л0
64 получить 610
80 зоскеъ создать сокет
82 соппесТ подключиться к серверу
83 ассер* * принять соединение
87 гепато отправить данные (ПОР)
88 Г©СУНГОМ получить данные (1ЮР)
89 гепйтзв отправить сообщение
90 гесугпа^ получить сообщение
Для 32-битных Ыпих номера зубсаПь другие!
I__________________________________________________
Итоги приложения
УУ1пс1ош5 АР1 — кегпе132 (файлы, память, процессы, реестр)
МЛпйошб АР) — и$ег32 (окна, сообщения, ввод)
УУтс1ауу5 АР1 —\л/$2_32 (сеть, сокеты)
Ипих 5у5са11$ — номера для х86_64 (ууп1е=1 г о реп=2, геаб=0)
ПРИЛОЖЕНИЕ Г. Ресурсы и сообщества
Г.1. Где брать сгаскте (учебные задачи)
1=6X1
I-----------------------------------------------
СКДСКМЕ И ЗАДАЧИ
сгасктез.опе
I---------------------------------------------------------------'
• Самый большой сайт с сгаскте
• От новичков до профи
• Есть решения и обсуждения
• Ы1р5://сгасктеБ .опе
I—_____________________________________________________________I
I--------------------------------------------------------------1
• Французский сайт с задачами по безопасности
• Есть раздел реверс-инжиниринга
• Проверка ответов
• Ы1р5: /Лим. гоо1-ше .ог^
I__________________________________________________________________Г |
I I
КеуегЕ±ге+кг
I I-------------------------------------------------------------------1 I
• Корейский сайт с задачами
• От простых до очень сложных
• И11:р5://геуег&тпЕ. кг
I__________________________________________________________________I I
I I
СТЕ-задачи
I I-------------------------------------------------------------------1 I
• Многие СТР имеют задачи по реверс-инжинирингу
| | • Ы-крз ://сТК1те,оге I I
I__________________________________________________________________I |
I I
I_________________________________________________________________________I
Г.2. Форумы и сообщества
ФОРУМЫ И СООБЩЕСТВА
Йи&ахап веиег$1пе
Г---------------------------------------------
• Русскоязычное сообщество реверс-инженеров
• Те1едгат-канал и чат
• Ы1р5://1Ё.те/ги551ап_геуег51пе
КСЕ Еогитз
• Старейший форум по реверс-инжинирингу
* ЫгрЕ://-Еогит,геиег$еепе1пееггпе.лег/
ЮА Рго СомтипзЛу
Официальный форум Нех-КауЕ
• КИрз://-Еогит. Иех-гауз. сот/
I__________________________________
КёйсИЛ
I---------------------------------------------------------------1
• г/ВеуегзеЕпехпеегЛпе
| * г/ЮАРйО |
| * г/Ма1«агеАпа1уз15
I_______________________________________________________________I
Г.З. Полезные сайты и инструменты
1:ек1
!------------------------------------------------------------------------------------1
ПОЛЕЗНЫЕ САЙТЫ I
Официальные:
I---------------------------------------------------------------1 I
• ЫТр5://ими.Ьех-гауьгсот/1с1з-рго/ — ЮА Рго
• : //шиш. Нех-гау^. сот/ргос1ис1:Б/^есотр11ег/
- Нех-Кау5 ОесотрИег
• Ы1р5://^Ыска-зге. ог§/ - 6П1с1га (бесплатная альтернатива)!
1---------------------------------------------------------------1 I
I
Плагины;
I---------------------------------------------------------------1 I
* Ь«р5://е1^иЬ.сот/кеу51:ог1ё-ег1е1Г1е/кеура1:сГ| - Кеура1:с11
* РИрз://@1-1:ЬиЬ~сот/пЦпНиз/ЮАЗсг!ри - скрипты
• ИИрз: //еПсЬиЬ.сот/йап1§а гди/СуЬегСНе-? - СуЬегСЬеГ
Справочники:
I-----------------------------------------------------------------1 I
• Ы1рз://сЭх .те/х8б/ - х86 инструкции
• М’Ьрз://агтсо^еггег.сот/ - дим согиеггег
• (11-ер5://с1ос5.я11сго50^1:.сот/еп-и5/^1пс1оыз/ы1п32/ар±/
- И1П(1оыб АР1
• 11"Ы:р5://тап7.ог'ё/Илих/тап-ра8ез/ - Цпих тап
1-----------------------------------------------------------------1 I
Г.4. Книги для дальнейшего изучения
КНИГИ ПО ТЕМЕ
Для новичков:
1
"РгасТ1са1 Веуегае Епд1пеег1п§" - Вгисе Вап^
"Кеуегзе ЕпЕ1пеег1пе -Еог* Ве^аппегз" - Оеппть УигтсЬеу
(есть бесплатная версия)
"ТЬе ЮА Рго Воок" - СЬгтб Еае1е
Для продолжающих:
* "РгасМса1 Ма1ыаге Дпа1у51з" - М1сМае1 51ког$к1
| • "Пче ДгЬ о-Е Мешогу Гогеп51с$" - М1сНае1 На1е ЩЬ
• "НеуегЕтп^: 5есгеТ5 о-? Веуег5е Еп^1пеег1Пй'' - Е1<1ас1 Е11ат|
|_
Итоги приложения
• Сгаскте&.опе — лучший сайт для практики
• КСЕ Еогиш5 — старейшее сообщество
• ОКНиЬ — тысячи плагинов и скриптов
• Книги — для углублённого изучени я
ЗАКЛЮЧЕНИЕ
Поздравляю! Вы прошли весь курс "!ОА Рго для чайников". Вы научились:
1. Устанавливать и настраивать ЮА
2. Загружать файлы и понимать, что видите
3. Использовать Е5 (декомпиляцию) как главную суперсилу
4. Находить строки и переходить к коду
5. Переименовывать и комментировать
6. Работать с типами данных и структурами
7. Использовать РЫКТ и Ьит1па
8. Отлаживать программы
9. Ставить брейкпоинты
10. Патчить программы
11. Устанавливать и использовать плагины
12. Писать скрипты на РуНЬоп
13. Работать с АКМ и мобилками
14. Анализировать вредоносное ПО
15. Находить уязвимости
16. Исправлять баги без исходников
Что дальше?
• Решайте сгаскте на сгаскте5.опе|
* Участвуйте в СТР
• Читайте книги из списка
• Практикуйтесь на реальных задачах
• Присоединяйтесь к сообществам
Помните: ЮА Рго — это инструмент. Как любой инструмент, он требует практики.
Чем больше вы работаете, тем лучше вы становитесь.
Удачи в ваших исследованиях!