Welcome to another exciting “Programming Thursdays” blog edition dedicated to red teaming and pen testing. Today, we’ll dive deep into Python – the powerful, versatile, and widely-used programming language that has become the go-to choice for many in our field. This article is designed for a technical audience and will provide plenty of code examples to help you get started or strengthen your Python skills. So, strap in, grab your black hoodies, and begin our journey into Python.

Introduction

The key features of Python include:

  • Easy-to-read syntax
  • Extensive standard library
  • Cross-platform compatibility
  • Strong support for integration with other languages
  • Object-oriented programming
  • Dynamic typing and automatic memory management

To begin, let’s ensure you have Python installed on your system. You can download the latest version of Python from the official website (https://www.python.org/downloads/). Once installed, open a terminal or command prompt, and type python or python3 (depending on your installation) to launch the Python interpreter. You should see a prompt similar to this:

Python 3.9.0 (default, Oct  6 2021, 19:53:50)
[GCC 10.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Now that we have Python up and running, let’s dive into some basic concepts and syntax.

Variables and Data Types

In Python, variables store values that can be manipulated throughout your program. Variables are dynamically typed, meaning you don’t need to declare their types explicitly. Python will automatically infer the type based on the value assigned. Here are the primary data types you’ll encounter in Python:

  • Integers: Whole numbers, e.g., 42
  • Floats: Decimal numbers, e.g., 3.14
  • Strings: Sequences of characters, e.g., "Hello, World!"
  • Lists: Ordered collections of items, e.g., [1, 2, 3]
  • Tuples: Immutable ordered collections of items, e.g., (1, 2, 3)
  • Dictionaries: Collections of key-value pairs, e.g., {'a': 1, 'b': 2}
  • Booleans: True or False values, e.g ., True, False

Here’s how to create and manipulate variables of different data types:

# Integers and floats
x = 42
y = 3.14

# Strings
name = "Alice"
greeting = f"Hello, {name}!"

# Lists
numbers = [1, 2, 3, 4, 5]
numbers.append(6)  # Adds 6 to the end of the list

# Tuples
point = (3, 4)

# Dictionaries
ages = {"Alice": 30, "Bob": 25}
ages["Charlie"] = 22  # Adds a new key-value pair to the dictionary

# Booleans
is_hacker = True
is_vulnerable = False

Operators

Operators in Python allow you to perform various operations on values and variables. Some standard operators include:

  • Arithmetic operators: +, -, *, /, //, %, **
  • Comparison operators: ==, !=, >, <, >=, <=
  • Logical operators: and, or, not
  • Bitwise operators: &, |, ^, ~, <<, >>
  • Membership operators: in, not in
  • Identity operators: is, is not

Here are some examples of using operators:

# Arithmetic operations
addition = 3 + 5
division = 15 / 3
modulo = 7 % 2
exponentiation = 2 ** 3

# Comparison operations
is_equal = 3 == 5
is_greater = 7 > 4

# Logical operations
result = True and False
another_result = not True

# Bitwise operations
bitwise_and = 3 & 5
bitwise_or = 3 | 5
bitwise_xor = 3 ^ 5

# Membership operations
check_membership = 3 in [1, 2, 3, 4, 5]
check_absence = 7 not in [1, 2, 3, 4, 5]

# Identity operations
x = [1, 2, 3]
y = [1, 2, 3]
z = x

are_same = x is z
are_different = x is not y

Control Structures

Control structures in Python enable you to control the flow of your program based on certain conditions. These structures include:

  • Conditional statements (if, elif, else)
  • Loops (for, while)
  • Loop control statements (break, continue, pass)

Here are some examples of control structures:

# Conditional statements
age = 25

if age < 18:
    print("You're not old enough!")
elif age >= 18 and age < 21:
    print("You're almost there!")
else:
    print("You're good to go!")

# For loop
for i in range(5):
    print(i)

# Looping through a list
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# While loop
count = 0
while count < 5:
    print(count)
    count += 1

# Break, continue, and pass
for num in range(10):
    if num == 5:
        break # Exit the loop
    elif num == 3:
        continue # Skip the current iteration
    else:
        pass # Do nothing (used as a placeholder)
    print(num)

Functions

Functions in Python are blocks of code that can be defined and called by name. Functions allow for code reuse and make programs more organized and easier to read. You can specify a function using the def keyword, followed by the function name and a pair of parentheses containing any input parameters.

Here’s an example of defining and calling a function:

# Define a function
def greet(name):
    return f"Hello, {name}!"

# Call the function
greeting = greet("Alice")
print(greeting)

Functions can also have default parameter values, allowing you to call the function without providing specific arguments:

def greet(name="Hacker"):
    return f"Hello, {name}!"

greeting = greet()  # Returns "Hello, Hacker!"
print(greeting)

Python for Pen Testing and Red Teaming

Python is an excellent choice for pen testing and red teaming due to its simplicity, extensive library support, and wide adoption in the security community. This section will explore some practical cases of Python being used in pen testing and red teaming.

Network scanning

Python can perform network scans to discover open ports and active services. The socket module in the standard library can help you achieve this:

import socket

target = "example.com"
ports = [21, 22, 80, 443]

def port_scan(host, port):
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.settimeout(1)
        s.connect((host, port))
        print(f"Port {port} is open on {host}")
        s.close()
    except:
        pass

for port in ports:
    port_scan(target, port)

Brute-forcing

Python can perform brute-force attacks to crack passwords or discover hidden directories. The following example demonstrates a simple password brute-forcing using a dictionary of common passwords:

import hashlib

password_hash = "5f4dcc3b5aa765d61d8327deb882cf99"  # "password" as MD5 hash
common_passwords = ["123456", "password", "123456789", "qwerty"]

def crack_password(password_list, target_hash):
    for password in password_list:
        hashed_password = hashlib.md5(password.encode()).hexdigest()
        if hashed_password == target_hash:
            return password

cracked_password = crack_password(common_passwords, password_hash)
print(f"Cracked password: {cracked_password}")

Web scraping and vulnerability identification

Python can be used for web scraping and identifying potential vulnerabilities in web applications. Here’s a basic example of web scraping using the requests and BeautifulSoup libraries:

import requests
from bs4 import BeautifulSoup

url = "https://example.com"
response = requests.get(url)
soup = BeautifulSoup(response.text, "html.parser")

# Extract all links on the page
links = soup.find_all("a")
for link in links:
    print(link["href"])

# Search for potentially vulnerable PHP pages
vulnerable_pages = [link["href"] for link in links if ".php" in link["href"]]
print(f"Potentially vulnerable pages: {vulnerable_pages}")

Note: Before running the above code, the requests and BeautifulSoup libraries need to be installed using pip install requests beautifulsoup4.

Pros and Cons for Pen Testers and Red Team Members

Pros

  1. Easy to learn: Python’s simple syntax and readability make it easy to understand, even for those new to programming.
  2. Extensive library support: Python has a rich ecosystem of libraries that can be leveraged for various tasks, such as network communication, cryptography, and web scraping.
  3. Large community: Python has a solid and active community, ensuring constant updates, support, and availability of resources.
  4. Cross-platform compatibility: Python can run on different operating systems, making it versatile for diverse environments.
  5. Scripting and automation: Python excels in scripting and automation tasks, making it suitable for automating pen testing and red teaming tasks.

Cons

  1. Performance: Python’s interpreted nature can lead to slower performance than compiled languages like C or C++. However, this is often not a significant issue for pen testing and red teaming tasks.
  2. Obfuscation and reverse engineering: Python’s readability can be a double-edged sword, as it may be easier for adversaries to understand and reverse-engineer your code. However, obfuscation techniques and tools can help mitigate this risk.

Conclusion

Python is a potent and versatile programming language that has found its way into the toolkits of many pen testers and red teamers. Its simplicity, readability, and extensive library support make it a popular choice for various tasks in the cybersecurity field.

In this article, we’ve covered the basics of Python, including variables and data types, operators, control structures, and functions. We’ve also explored how Python can be used in pen testing and red teaming scenarios, with examples ranging from network scanning to brute-forcing and web scraping. Lastly, we’ve discussed the pros and cons of using Python in the context of pen testing and red teaming.

With this knowledge, you’re better equipped to leverage Python in your cybersecurity endeavors. Keep honing your skills and exploring the vast array of tools and libraries available in the Python ecosystem, and you’ll undoubtedly become an even more formidable hacker. Remember, with great power comes great responsibility – always use your skills ethically and for the greater good. Happy hacking!