WIFI DEAUTHER

Project report submitted in partial fulfilment of the requirements for the

course-Digital Electronics and Computer Architecture (23IC001) of

Bachelor of Engineering
in

Computer Science and Engineering

Submitted by

TANISHA SHARMA
(2310990901)
TANREET KAUR
(2310990902)
TARANGIT CHHABRA
(2310990904)
TARUN SAINI
(2310990905)

Group:- G11, B.E.-2023 Batch

Chitkara University Institute of Engineering and Technology

Department of Interdisciplinary Courses in Engineering (DICE)
CHITKARA UNIVERSITY
PUNJAB
MAY, 2024
 WIFI DEAUTHER
Project report submitted in partial fulfilment of the requirements for the
course-Digital Electronics and Computer Architecture (23IC001) of

Bachelor of Engineering
in

Computer Science and Engineering

Submitted by

TANISHA SHARMA
(2310990901)
TANREET KAUR
(2310990902)
TARANGIT CHHABRA
(2310990904)
TARUN SAINI
(2310990905)

Under the Supervision of

Dr. Anupma
Assistant Professor

Chitkara University Institute of Engineering and Technology

Department of Interdisciplinary Courses in Engineering (DICE)
CHITKARA UNIVERSITY
PUNJAB
MAY, 2024
 CERTIFICATE

This is to certify that the project titled ”WIFI DEAUTHER” submitted to the
Chitkara University Institute of Engineering and Technology (CUIET) by
TANISHA SHARMA(2310990901), TANREET KAUR(2310990902),
TARANGIT CHHABRA(2310990904), TARUN SAINI (2310990905) is a bonafide
record of the work done by the students towards partial fulfilment of requirements for
the course- Digital Electronics and Computer Architecture (23IC001) of Bachelor of
Engineering in Computer Science and Engineering.

Supervisor/Project Guide Course/Project Coordinator

Signature

Name Dr. Anupama Dr. Gaurav Sharma

Designation Assistant Professor Associate Professor

Department Department of Interdisciplinary Department of Interdisciplinary

Courses in Engineering Courses in Engineering

Place: Chitkara University, Rajpura, Punjab

Date: 20 May, 2024

 Candidates’ Declaration
We, TANISHA SHARMA (2310990901), TANREET KAUR (2310990902), TARANGIT
CHHABRA (2310990904), TARUN SAINI (2310990905), of Group- 11, B.E. -2023 batch of
Chitkara University, Punjab hereby declare that the Digital Electronics and Computer
Architecture (DECA) project entitled “WIFI Deauther” Is an original work and data provided in
the study is authentic to the best of our knowledge. This project has not been submitted by us
to any other institute for the award of any other course.

Contribution Details:

Sr. Student Name Roll No. Contact Contribution in Project Signature

No. Number
1. Tanisha Sharma 2310990901 9662000434 TESTING AND
TROUBLESHOOTING

2. Tanreet Kaur 2310990902 7658851907 TESTNG AND

DOCUMENTATION

3. Tarangit Chhabra 2310990904 9812134865 TECHNICAL DEVELOPMENT

4. Tarun Saini 2310990905 8968782891 PROTOTYPE AND BUILDING

 ACKNOWLEDGEMENT

Completion of this project would not have been possible without the help of many people,
to whom we are very thankful. First of all, we would like to convey our sincere thanks to Dr.
Rajneesh Talwar, Dean, CUIET-DICE, Chitkara University, Punjab for his constant support,
motivation and encouragement towards projects and proving healthy environment for working
on real time problems.

We express our sincere gratitude to Dr. Sunil Kumar, Associate Dean, CSE-I year for
his constant support and cooperation.

We would like to express our sincere gratitude to our supervisor, …….#project guide
name with designation….. His/Her constant motivation, guidance and support helped us a great
deal to achieve this feat.

We would like to thank Dr. Gaurav Sharma, Associate Professor, Course

Coordinator-DECA, DICE for guiding and inspiring us in many ways. We are also thankful to
other faculty members and staff of the Department of Interdisciplinary Courses in Engineering
and Computer Science and Engineering department for their support.

We also thank our lab instructors Mr. Umesh Joshi, Mr. Subhash Kumar, Mr. Madan
Mohan Sharma and Mr. Rakesh who guided and helped us in many ways in project as well as
in lab experiments throughout the semester.

We wish a deep sense of gratitude and heartfelt thanks to the management for providing
excellent lab facilities and tools.
 ABSTRACT

This project ventures into the fascinating, yet ethically sensitive, realm of Wi-Fi

security through the development and analysis of a custom deauther tool built with an ESP8266

microcontroller. Stepping beyond a mere technical exploit, the project prioritizes a

comprehensive educational experience, empowering users to understand both the intricacies of

Wi-Fi protocols and the potential vulnerabilities therein. The constructed deauther, meticulously

designed to comply with ethical guidelines and operate solely on authorized networks, serves as

a practical platform for dissecting various deauthentication techniques. Through hands-on

implementation and exploration of beacon flooding methods, fake access point creation, and

targeted disconnections, users gain invaluable insights into the inner workings of Wi-Fi security

architecture. However, the project doesn't stop at technical exploration. It emphasizes the crucial

aspect of responsible security practices, highlighting the ethical implications of deauthentication

tools and fostering awareness of potential misuse. By delving into legal regulations and

highlighting the importance of informed consent, the project encourages responsible technology

usage and promotes a mindful approach to Wi-Fi network security. Ultimately, this project serves

as a valuable conduit for technical learning, while concurrently nurturing responsible citizens in

the digital age.

In summary, this DECA project showcases the integration of digital electronics, computer

architecture, networking knowledge, and ethical hacking skills to construct a deauthentication

tool.

Application Area(s) of the Project:

Cybersecurity and Educational purposes

Technology Stack:
Arduino IDE, NodeMCU ESP8266, C and CPP
 TABLE OF CONTENTS
Certificate

Candidates’ Declaration

Acknowledgement

Abstract

List of Figures

Table of Contents

1 INTRODUCTION

2 RELATED WORK

3 HARDWARE COMPONENTS

4 PROJECT DETAILS

5 RESULTS

References

Appendix A

Source Code
 CHAPTER 1

INTRODUCTION

In the rapidly evolving landscape of digital technology, the intersection of Digital Electronics and

Computer Architecture (DECA) stands as a crucial domain for understanding and shaping the

future of computing systems. This project delves into the realm of cybersecurity within DECA,

focusing on the development of a deauthentication tool—an integral component of network

security assessment.

Networking has become an indispensable facet of our connected world, and as technology

progresses, so do the challenges associated with securing our digital infrastructure. Wireless

networks, in particular, present a dynamic environment where vulnerabilities must be identified

and addressed proactively. In response to this imperative, the project places a spotlight on the

creation of a deauthentication tool that employs a network adapter to execute targeted attacks.

By integrating principles of digital electronics and computer architecture, the project encapsulates

a holistic approach to understanding the inner workings of network security. The careful

orchestration of a controlled environment ensures that the deauthentication attacks are conducted

responsibly, solely targeting networks under the ownership or authorization of the researcher.

The use of Aircrack-ng, a versatile suite renowned in the ethical hacking community, adds a layer

of sophistication to the project, empowering researchers to comprehensively assess and fortify

wireless network defenses.

As we embark on this exploration, it is imperative to emphasize the ethical considerations and

legal frameworks that govern cybersecurity practices. The project aligns with the principles of

responsible hacking, acknowledging the importance of ethical conduct in the pursuit of

knowledge and practical application within the DECA landscape.

In essence, this project serves as a gateway to the dynamic intersection of DECA, networking,

and ethical hacking, providing a platform for enthusiasts and researchers to delve into the

intricacies of secure digital communication while maintaining the highest standards of ethical

responsibility.
 CHAPTER 2

RELATED WORK
Wi-Fi deauthers, also known as deauthentication devices, have garnered attention due

to their controversial nature. These devices disrupt wireless networks by sending

deauthentication packets to connected devices, effectively disconnecting them from the

network. While some projects focus on security research and education, others raise

ethical concerns. Let’s explore a few existing projects related to Wi-Fi jammers:

1. Wi-Fi-Jammer Using Python Script (bhikandeshmukh/Wi-Fi-Jammer)

• Description: This project aims to create a Wi-Fi jammer using Python scripts.

It operates as a black-hat security tool, simulating deauthentication attacks.

• Features:

o Deauthenticates users from Wi-Fi networks continuously.

o Written in Python.

• GitHub Repository: Wi-Fi-Jammer

2. ShockWave (DubiousCactus/ShockWave)

• Description: ShockWave identifies all connected devices on a local network

and sends deauthentication packets to each of them. It acts as a Wi-Fi jammer

but includes a white-list feature.

• Features:

o White-list functionality.

o Command-line interface (CLI).

 • GitHub Repository: ShockWave

3. How to Build a Wi-Fi Jammer (0x77ff/How-to-build-a-WIFI-jammer)

• Description: This guide provides step-by-step instructions for building

Arduino-based Wi-Fi jammers. It explores the hardware and software aspects

of creating a Wi-Fi deauthentication device.

• Features:

o Uses nRF24L01 for communication.

o Ideal for educational purposes.

• GitHub Repository: How-to-build-a-WIFI-jammer

4. Tostapane (n0nexist/Tostapane)

• Description: Tostapane is a Wi-Fi deauthenticator written in Python 3. It

continuously performs deauthentication attacks on all detectable stations.

• Features:

o Python-based.

o Focuses on deauthentication attacks.

• GitHub Repository: Tostapane

In conclusion, Wi-Fi jammers serve as both educational tools and potential security

threats. As technology advances, we must strike a balance between exploration and

responsible usage.
 CHAPTER 3

HARDWARE COMPONENTS

1.NodeMCU ESP2866:

1. Work Principle:

o NodeMCU ESP8266 combines a microcontroller (ESP8266 or ESP32)

with built-in Wi-Fi functionality.

o It allows developers to create IoT devices, collect sensor data, and

communicate over wireless networks.

2. Function:

o NodeMCU serves as a versatile development board for Wi-Fi-enabled

projects.

o It supports GPIO, PWM, and ADC, making it ideal for home

automation, sensor networks, and smart devices.

2. Display Unit (Oled Display):

1. Function:

o The SSD1306 OLED display is a small, monocolor screen with 128×64

pixels.

o Its primary function is to display information such as text, graphics, and

icons.

o It is commonly used in IoT projects, sensor data visualization, and low-

power applications.

2. Work Principle:

o The SSD1306 OLED display operates by emitting light directly from

individual pixels.

o Each pixel consists of organic compounds that emit light when an

electric current passes through them.

o The SSD1306 IC (Integrated Circuit) controls the display, updating each

pixel’s state based on the data received.

 3. PCB Printed Circuit Board:

1.Function:

• Provides mechanical support and electrical connections for electronic

components.

• Enables the flow of electric current along pre-designed routes, achieving

functions such as amplification, modulation, and coding.

2.Work Principle:

• PCBs isolate surface copper foil conductive layers through insulating

material.

• These layers allow current to flow through components, creating

functional electronic circuits.

 CHAPTER 4

PROJECT DETAILS

Introduction

Wi-Fi deauthenticators, though often used maliciously, can be valuable for

testing network security. This project explores building a controlled Wi-Fi

deauther for educational purposes. The challenge is to balance functionality for

testing vulnerabilities with robust safety measures to prevent misuse and ensure

responsible development.

Circuit/Block Diagram

Fig. 4.1 Circuit/Block Diagram

 Fig. 4.2 Project Photo

Working of Project

1. Purpose and Function:

o Exploit loopholes: Wi-Fi deauth tools take advantage of weaknesses in

the Wi-Fi protocol.

o Tricky Disconnection: Unlike Jammers, they don't overpower signals,

but instead, deceive connected devices into disconnecting from the

network.

o Disruption for Users: This can be disruptive and inconvenient for

legitimate users, causing them to lose internet access and experience

frustration.
 2. Working Principle:

o Falling for the Deception: When a device receives a deauthentication

frame, even a fake one targeting its MAC address and access point, it's

programmed to assume it's been disconnected from the network.

o They operate within a specific frequency range (typically from 2.4 GHz

to 2.5 GHz) to effectively block Wi-Fi signals.

o A Wi-Fi deauther exploits this lack of encryption by forging fake

deauthentication frames. These frames mimic legitimate ones sent by
the access point, telling a specific device (identified by its MAC
address) that it's been disconnected from the network.

3. Range and Coverage:

o The deauther's range depends on factors like its antenna and transmit

power. Typically, a Wi-Fi deauther can affect devices within a radius of

tens of meters.

SOFTWARE USED FOR CODING

❖ ESPlorer IDE

o Open Source: The ESPlorer IDE is open-source software, freely available

for download and use by anyone.

o Cross-Platform: It is compatible with major operating systems including

Windows, macOS, and Linux.

o Code Editor: Provides a text editor for writing and editing Arduino sketches

(programs) using C and C++ programming languages.

 o Syntax Highlighting: Supports syntax highlighting for easier code

readability, distinguishing between keywords, variables, comments, etc.

o Serial Monitor: Includes a built-in serial monitor for debugging and

communication with the Arduino board via the USB connection.

CHAPTER 5

RESULTS
The WiFi Deauthenticator project focuses on detecting and mitigating Denial-of-
Service (DoS) attacks specifically targeting wireless networks. Here are the key details
about this project:

1. Objective:

o The project aims to address the security challenges posed by IEEE

802.11 wireless networks.

o It specifically deals with WiFi Denial-of-Service (DOS) attacks.

2. Background:

o Wireless networks are ubiquitous, from cafes to airport terminals.

o Over time, various flaws in wireless systems have been discovered,

including attacks like the caffe latte attack and the KRACK attack.

o DOS attacks disrupt the connection between the Access Point

(AP) and clients (such as cell phones and laptops).

3. Project Scope:

o The WiFi Deauthenticator project focuses on practical detection of

WiFi DOS attacks.

o While some network equipment has built-in features to prevent such

attacks, their effectiveness is often inadequate.

4. Detection Approach:
 o The project combines packet crafting skills using Scapy (a Python
library for packet manipulation) and Python scripting.

o By analyzing network traffic and crafting custom packets, it detects and

responds to WiFi DOS attacks.

Application Areas:

The WiFi Deauthenticator project has practical applications in several areas related to

wireless networks and security. Here are some key application domains:

1. Network Security Testing and Assessments:

o Penetration Testing: Security professionals use WiFi deauther tools to

assess the robustness of wireless networks against denial-of-service

attacks.

o Vulnerability Assessment: Detecting vulnerabilities in WiFi networks

helps organizations secure their infrastructure.

2. Educational and Research Purposes:

o The project serves as a proof of concept for research and teaching.

o It helps students and researchers understand WiFi security, network

protocols, and wireless communication.

3. Network Monitoring and Troubleshooting:

o Network Administrators: Use WiFi deauthers to monitor network

behavior, identify rogue devices, and troubleshoot connectivity issues.

 o Detecting Unauthorized Devices: Identify unauthorized devices

attempting to connect to the network.

Conclusion:

In conclusion, the WiFi Deauthenticator project addresses WiFi Denial-of-Service

(DOS) attacks. By crafting custom packets using Python’s Scapy library, it detects

vulnerabilities in wireless networks. The tool helps ethical hackers and network

administrators assess network security, troubleshoot issues, and raise awareness about

WiFi attacks. Responsible usage is crucial to prevent misuse and maintain network

stability.
REFERENCES

Report citation references:

1. Chatgpt and Google and Github

2. Sites used for help: https://github.com/SpacehuhnTech/esp8266_deauther

https://deauther.com/

3. Guidance from Deca teacher and Youtube.

 APPENDIX A

Source Code of the Project :

#include "Accesspoints.h"

Accesspoints::Accesspoints() {
list = new SimpleList<AP>;
}

void Accesspoints::sort() {
list->setCompare([](AP& a, AP& b) -> int {
if (WiFi.RSSI(a.id) > WiFi.RSSI(b.id)) return -1;

if (WiFi.RSSI(a.id) == WiFi.RSSI(b.id)) return 0;

return 1;
});
list->sort();
changed = true;
}

void Accesspoints::sortAfterChannel() {
list->setCompare([](AP& a, AP& b) -> int {
if (WiFi.channel(a.id) < WiFi.channel(b.id)) return -1;

if (WiFi.channel(a.id) == WiFi.channel(b.id)) return 0;

return 1;
});
list->sort();
changed = true;
}
void Accesspoints::add(uint8_t id, bool selected) {
list->add(AP{ id, selected });
changed = true;
}

void Accesspoints::printAll() {
prntln(AP_HEADER);
int c = count();

if (c == 0) prntln(AP_LIST_EMPTY);
else
for (int i = 0; i < c; i++) print(i, i == 0, i == c - 1);
}

void Accesspoints::printSelected() {
prntln(AP_HEADER);
int max = selected();

if (selected() == 0) {
prntln(AP_NO_AP_SELECTED);
return;
}
int c = count();
int j = 0;

for (int i = 0; i < c && j < max; i++) {

if (getSelected(i)) {
print(i, j == 0, j == max - 1);
j++;
}
}
}

void Accesspoints::print(int num) {

print(num, true, true);
}

void Accesspoints::print(int num, bool header, bool footer) {

if (!check(num)) return;

if (header) {
prntln(AP_TABLE_HEADER);
prntln(AP_TABLE_DIVIDER);
}
prnt(leftRight(String(), (String)num, 2));
prnt(leftRight(String(SPACE) + getSSID(num), String(), 33));
prnt(leftRight(String(SPACE) + getNameStr(num), String(), 17));
prnt(leftRight(String(SPACE), (String)getCh(num), 3));
prnt(leftRight(String(SPACE), (String)getRSSI(num), 5));
prnt(leftRight(String(SPACE), getEncStr(num), 5));
prnt(leftRight(String(SPACE) + getMacStr(num), String(), 18));
prnt(leftRight(String(SPACE) + getVendorStr(num), String(), 9));
prntln(leftRight(String(SPACE) + getSelectedStr(num), String(), 9));

if (footer) {
prntln(AP_TABLE_DIVIDER);
}
}

String Accesspoints::getSSID(int num) {

if (!check(num)) return String();

if (getHidden(num)) {
 return str(AP_HIDDE_SSID);
} else {
String ssid = WiFi.SSID(getID(num));
ssid = ssid.substring(0, 32);
ssid = fixUtf8(ssid);
return ssid;
}
}

String Accesspoints::getNameStr(int num) {

if (!check(num)) return String();

return names.find(getMac(num));
}

uint8_t Accesspoints::getCh(int num) {

if (!check(num)) return 0;

return WiFi.channel(getID(num));
}

int Accesspoints::getRSSI(int num) {

if (!check(num)) return 0;

return WiFi.RSSI(getID(num));
}

uint8_t Accesspoints::getEnc(int num) {

if (!check(num)) return 0;

return WiFi.encryptionType(getID(num));
}
String Accesspoints::getEncStr(int num) {
if (!check(num)) return String();

switch (getEnc(num)) {
case ENC_TYPE_NONE:
return String(DASH);

break;

case ENC_TYPE_WEP:
return str(AP_WEP);

break;

case ENC_TYPE_TKIP:
return str(AP_WPA);

break;

case ENC_TYPE_CCMP:
return str(AP_WPA2);

break;

case ENC_TYPE_AUTO:
return str(AP_AUTO);

break;
}
return String(QUESTIONMARK);
}
String Accesspoints::getSelectedStr(int num) {
return b2a(getSelected(num));
}

uint8_t* Accesspoints::getMac(int num) {

if (!check(num)) return 0;

return WiFi.BSSID(getID(num));
}

String Accesspoints::getMacStr(int num) {

if (!check(num)) return String();

uint8_t* mac = getMac(num);

return bytesToStr(mac, 6);

}

String Accesspoints::getVendorStr(int num) {

if (!check(num)) return String();

return searchVendor(getMac(num));
}

bool Accesspoints::getHidden(int num) {

if (!check(num)) return false;

return WiFi.isHidden(getID(num));
}

bool Accesspoints::getSelected(int num) {

 if (!check(num)) return false;

return list->get(num).selected;
}

uint8_t Accesspoints::getID(int num) {

if (!check(num)) return -1;

return list->get(num).id;
}

void Accesspoints::select(int num) {

if (!check(num)) return;

internal_select(num);

prnt(AP_SELECTED);
prntln(getSSID(num));

changed = true;
}

void Accesspoints::deselect(int num) {

if (!check(num)) return;

internal_deselect(num);

prnt(AP_DESELECTED);
prntln(getSSID(num));

changed = true;
}
void Accesspoints::remove(int num) {
if (!check(num)) return;

prnt(AP_REMOVED);
prntln(getSSID(num));

internal_remove(num);

changed = true;
}

void Accesspoints::select(String ssid) {

for (int i = 0; i < list->size(); i++) {
if (getSSID(i).equalsIgnoreCase(ssid)) select(i);
}
}

void Accesspoints::deselect(String ssid) {

for (int i = 0; i < list->size(); i++) {
if (getSSID(i).equalsIgnoreCase(ssid)) deselect(i);
}
}

void Accesspoints::remove(String ssid) {

for (int i = 0; i < list->size(); i++) {
if (getSSID(i).equalsIgnoreCase(ssid)) remove(i);
}
}

void Accesspoints::selectAll() {
for (int i = 0; i < count(); i++) list->replace(i, AP{ list->get(i).id, true });
 prntln(AP_SELECTED_ALL);
changed = true;
}

void Accesspoints::deselectAll() {
for (int i = 0; i < count(); i++) list->replace(i, AP{ list->get(i).id, false });
prntln(AP_DESELECTED_ALL);
changed = true;
}

void Accesspoints::removeAll() {
while (count() > 0) internal_remove(0);
prntln(AP_REMOVED_ALL);
changed = true;
}

int Accesspoints::find(uint8_t id) {

int s = list->size();

for (int i = 0; i < s; i++) {

if (list->get(i).id == id) return i;
}
return -1;
}

int Accesspoints::count() {
return list->size();
}

int Accesspoints::selected() {
int c = 0;
 for (int i = 0; i < list->size(); i++) c += list->get(i).selected;
return c;
}

bool Accesspoints::check(int num) {

if (internal_check(num)) return true;

prnt(AP_NO_AP_ERROR);
prntln((String)num);
return false;
}

bool Accesspoints::internal_check(int num) {

return num >= 0 && num < count();
}

void Accesspoints::internal_select(int num) {

list->replace(num, AP{ list->get(num).id, true });
}

void Accesspoints::internal_deselect(int num) {

list->replace(num, AP{ list->get(num).id, false });
}

void Accesspoints::internal_remove(int num) {

list->remove(num);
}