Merge branch 'x4nth055:master' into master

Author: toby-developer

README.md

@@ -0,0 +1 @@
+# [Bluetooth Device Scanning in Python](https://thepythoncode.com/article/build-a-bluetooth-scanner-in-python)

ethical-hacking/bluetooth-scanner/README.md

@@ -0,0 +1,25 @@
+# Import bluetooth from the PyBluez module.
+import bluetooth
+
+def scan_bluetooth_devices():
+    try:
+        # Discover Bluetooth devices with names and classes.
+        discovered_devices = bluetooth.discover_devices(lookup_names=True, lookup_class=True)
+        
+        # Display information about the scanning process.
+        print('[!] Scanning for active devices...')
+        print(f"[!] Found {len(discovered_devices)} Devices\n")
+
+        # Iterate through discovered devices and print their details.
+        for addr, name, device_class in discovered_devices:
+            print(f'[+] Name: {name}')
+            print(f'[+] Address: {addr}')
+            print(f'[+] Device Class: {device_class}\n')
+    
+    except Exception as e:
+        # Handle and display any exceptions that occur during device discovery.
+        print(f"[ERROR] An error occurred: {e}")
+
+
+# Call the Bluetooth device scanning function when the script is run
+scan_bluetooth_devices()

ethical-hacking/bluetooth-scanner/bluetooth_scanner.py

@@ -0,0 +1 @@
+pybluez2

ethical-hacking/bluetooth-scanner/requirements.txt

@@ -0,0 +1 @@
+# [How to Create a Custom Wordlist in Python](https://thepythoncode.com/article/make-a-wordlist-generator-in-python)

ethical-hacking/bruteforce-wordlist-generator/README.md

@@ -0,0 +1,36 @@
+# Import the argparse module for handling command line arguments.
+# Import the itertools module for generating combinations.
+import argparse, itertools
+
+
+# Define a function to generate a wordlist based on given parameters.
+def generate_wordlist(characters, min_length, max_length, output_file):
+    # Open the output file in write mode.
+    with open(output_file, 'w') as file:
+        # Iterate over the range of word lengths from min_length to max_length.
+        for length in range(min_length, max_length + 1):
+            # Generate all possible combinations of characters with the given length.
+            for combination in itertools.product(characters, repeat=length):
+                # Join the characters to form a word and write it to the file
+                word = ''.join(combination)
+                file.write(word + '\n')
+
+
+# Create an ArgumentParser object for handling command line arguments.
+parser = argparse.ArgumentParser(description="Generate a custom wordlist similar to crunch.")
+
+# Define command line arguments.
+parser.add_argument("-c", "--characters", type=str, default="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
+                    help="Set of characters to include in the wordlist")
+parser.add_argument("-min", "--min_length", type=int, default=4, help="Minimum length of the words")
+parser.add_argument("-max", "--max_length", type=int, default=6, help="Maximum length of the words")
+parser.add_argument("-o", "--output_file", type=str, default="custom_wordlist.txt", help="Output file name")
+
+# Parse the command line arguments.
+args = parser.parse_args()
+
+# Call the generate_wordlist function with the provided arguments.
+generate_wordlist(args.characters, args.min_length, args.max_length, args.output_file)
+
+# Print a message indicating the wordlist has been generated and saved.
+print(f"[+] Wordlist generated and saved to {args.output_file}")

ethical-hacking/bruteforce-wordlist-generator/wordlist_gen.py

@@ -0,0 +1,2 @@
+# [How to Implement the Caesar Cipher in Python](https://thepythoncode.com/article/implement-caesar-cipher-in-python)
+# [How to Crack the Caesar Cipher in Python](https://thepythoncode.com/article/how-to-crack-caesar-cipher-in-python)

ethical-hacking/caesar-cipher/README.md

@@ -0,0 +1,46 @@
+import sys  # The sys module for system-related operations.
+from colorama import Fore, init  # Import the colorama for colored text
+
+init()  # Initialize the colorama library for colored text.
+
+
+def implement_caesar_cipher(message, key, decrypt=False):
+    # Initialize an empty string to store the result.
+    result = ""
+    # Iterate through each character in the user's input message.
+    for character in message:
+        # Check if the character is an alphabet letter.
+        if character.isalpha():
+            # Determine the shift amount based. i.e the amount of times to be shifted e.g 2,3,4....
+            shift = key if not decrypt else -key
+            # Check if the character is a lowercase letter.
+            if character.islower():
+                # Apply Caesar cipher transformation for lowercase letters.
+                result += chr(((ord(character) - ord('a') + shift) % 26) + ord('a'))
+            else:
+                # Apply Caesar cipher transformation for uppercase letters.
+                result += chr(((ord(character) - ord('A') + shift) % 26) + ord('A'))
+        else:
+            # Preserve non-alphabet characters as they are.
+            result += character
+    return result  # Return the encrypted or decrypted result.
+
+
+# Prompt the user to enter the text to be encrypted
+text_to_encrypt = input(f"{Fore.GREEN}[?] Please Enter your text/message: ")
+# Prompt the user to specify the shift length (the key).
+key = int(input(f"{Fore.GREEN}[?] Please specify the shift length: "))
+
+
+# Check if the specified key is within a valid range (0 to 25).
+if key > 25 or key < 0:
+    # Display an error message if the key is out of range.
+    print(f"{Fore.RED}[!] Your shift length should be between 0 and 25 ")
+    sys.exit()  # Exit the program if the key is invalid.
+
+# Encrypt the user's input using the specified key.
+encrypted_text = implement_caesar_cipher(text_to_encrypt, key)
+
+# Display the encrypted text.
+print(f"{Fore.GREEN}[+] {text_to_encrypt} {Fore.MAGENTA}has been encrypted as {Fore.RED}{encrypted_text}")
+

ethical-hacking/caesar-cipher/caeser_cipher.py

@@ -0,0 +1,55 @@
+# Import colorama for colorful text.
+from colorama import Fore, init
+
+init()
+
+
+# Define a function for Caesar cipher encryption.
+def implement_caesar_cipher(text, key, decrypt=False):
+    # Initialize an empty string to store the result.
+    result = ""
+
+    # Iterate through each character in the input text.
+    for char in text:
+        # Check if the character is alphabetical.
+        if char.isalpha():
+            # Determine the shift value using the provided key (or its negation for decryption).
+            shift = key if not decrypt else -key
+
+            # Check if the character is lowercase
+            if char.islower():
+                # Apply the Caesar cipher encryption/decryption formula for lowercase letters.
+                result += chr(((ord(char) - ord('a') + shift) % 26) + ord('a'))
+            else:
+                # Apply the Caesar cipher encryption/decryption formula for uppercase letters.
+                result += chr(((ord(char) - ord('A') + shift) % 26) + ord('A'))
+        else:
+            # If the character is not alphabetical, keep it as is e.g. numbers, punctuation
+            result += char
+
+    # Return the result, which is the encrypted or decrypted text
+    return result
+
+
+# Define a function for cracking the Caesar cipher.
+def crack_caesar_cipher(ciphertext):
+    # Iterate through all possible keys (0 to 25) as there 26 alphabets.
+    for key in range(26):
+        # Call the caesar_cipher function with the current key to decrypt the text.
+        decrypted_text = implement_caesar_cipher(ciphertext, key, decrypt=True)
+
+        # Print the result, showing the decrypted text for each key
+        print(f"{Fore.RED}Key {key}: {decrypted_text}")
+
+
+# Initiate a continuous loop so the program keeps running.
+while True:
+    # Accept user input.
+    encrypted_text = input(f"{Fore.GREEN}[?] Please Enter the text/message to decrypt: ")
+    # Check if user does not specify anything.
+    if not encrypted_text:
+        print(f"{Fore.RED}[-] Please specify the text to decrypt.")
+    else:
+        crack_caesar_cipher(encrypted_text)
+
+

ethical-hacking/caesar-cipher/crack_ceaser_cipher.py

@@ -0,0 +1 @@
+colorama

ethical-hacking/caesar-cipher/requirements.txt

@@ -0,0 +1 @@
+# [How to Crack the Affine Cipher in Python](https://thepythoncode.com/article/how-to-crack-the-affine-cipher-in-python)

ethical-hacking/crack-affine-cipher/README.md

@@ -0,0 +1,92 @@
+# Import the needed libraries.
+import string
+from colorama import Fore, init
+
+# Initialise colorama.
+init()
+
+
+# Function to get Euclidean Algorithm.
+def extended_gcd(a, b):
+    """
+    Extended Euclidean Algorithm to find the greatest common divisor
+    and coefficients x, y such that ax + by = gcd(a, b).
+    """
+    if a == 0:
+        return (b, 0, 1)
+    else:
+        g, x, y = extended_gcd(b % a, a)
+        return (g, y - (b // a) * x, x)
+
+
+# Function to get the modular Inverse
+def modular_inverse(a, m):
+    """
+    Compute the modular multiplicative inverse of a modulo m.
+    Raises an exception if the modular inverse does not exist.
+    """
+    g, x, y = extended_gcd(a, m)
+    if g != 1:
+        raise Exception('Modular inverse does not exist')
+    else:
+        return x % m
+
+
+# Function to decrypt our message.
+def affine_decrypt(ciphertext, a, b):
+    """
+    Decrypt a message encrypted with the Affine Cipher using
+    the given key components a and b.
+    """
+    alphabet = string.ascii_uppercase
+    m = len(alphabet)
+    plaintext = ''
+
+    # Compute the modular multiplicative inverse of a.
+    a_inv = modular_inverse(a, m)
+
+    # Iterate through each character in the ciphertext.
+    for char in ciphertext:
+        # Check if the character is in the alphabet
+        if char in alphabet:
+            # If it's an alphabet letter, decrypt it.
+            # Find the index of the character in the alphabet.
+            c = alphabet.index(char)
+            # Apply the decryption formula: a_inv * (c - b) mod m.
+            p = (a_inv * (c - b)) % m
+            # Append the decrypted character to the plaintext.
+            plaintext += alphabet[p]
+        else:
+            # If the character is not in the alphabet, keep it unchanged.
+            plaintext += char
+
+    # Return the decrypted plaintext.
+    return plaintext
+
+
+# Function to peform brute force attack.
+def affine_brute_force(ciphertext):
+    """
+    Brute-force attack to find possible keys for an Affine Cipher
+    and print potential decryptions for manual inspection.
+    """
+    alphabet = string.ascii_uppercase
+    m = len(alphabet)
+
+    # Iterate through possible values for a.
+    for a in range(1, m):
+        # Ensure a and m are coprime.
+        if extended_gcd(a, m)[0] == 1:
+            # Iterate through possible values for b.
+            for b in range(0, m):
+                # Decrypt using the current key.
+                decrypted_text = affine_decrypt(ciphertext, a, b)
+
+                # Print potential decryption for manual inspection.
+                print(f"Key (a={a}, b={b}): {decrypted_text}")
+
+
+ciphertext = input(f"{Fore.GREEN}[?] Enter Message to decrypt: ")
+
+# Perform a brute-force attack to find potential decrypted message.
+affine_brute_force(ciphertext)

ethical-hacking/crack-affine-cipher/affine_cipher_decrypt.py

@@ -0,0 +1 @@
+colorama

ethical-hacking/crack-affine-cipher/requirements.txt

@@ -0,0 +1 @@
+# [How to Perform DNS Enumeration in Python](https://www.thepythoncode.com/article/dns-enumeration-with-python)

ethical-hacking/dns-enumeration/README.md

@@ -0,0 +1,17 @@
+import dns.resolver
+
+# Set the target domain and record type
+target_domain = "thepythoncode.com"
+record_types = ["A", "AAAA", "CNAME", "MX", "NS", "SOA", "TXT"]
+# Create a DNS resolver
+resolver = dns.resolver.Resolver()
+for record_type in record_types:
+    # Perform DNS lookup for the specified domain and record type
+    try:
+        answers = resolver.resolve(target_domain, record_type)
+    except dns.resolver.NoAnswer:
+        continue
+    # Print the answers
+    print(f"{record_type} records for {target_domain}:")
+    for rdata in answers:
+        print(f" {rdata}")

ethical-hacking/dns-enumeration/dns_enumeration.py

@@ -0,0 +1 @@
+dnspython

ethical-hacking/dns-enumeration/requirements.txt

@@ -0,0 +1 @@
+# [How to Generate Fake User Data in Python](https://thepythoncode.com/article/generate-fake-user-data-in-python)