Getting free internet on a cruise, saving $170

FIRST_NAME=YourFirstName
LAST_NAME=YourLastName
DOB=YYYY-MM-DD
BOOKING_ID=YourBookingID
ROOM_NUMBER=YourRoomNumber
PASSWORD=YourPassword

# Not doing uv's script syntax

import time
import requests
from rich.pretty import pprint

import os
from dotenv import load_dotenv
import random
from netaddr import EUI, mac_unix_expanded

load_dotenv()

# ONLY_RUN_ONCE = False

FIRST_NAME = os.getenv("FIRST_NAME")
LAST_NAME = os.getenv("LAST_NAME")
DOB = os.getenv("DOB")
BOOKING_ID = os.getenv("BOOKING_ID")
PASSWORD = os.getenv("PASSWORD")
ROOM_NUMBER = os.getenv("ROOM_NUMBER")

USER_AGENT = "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Mobile/15E148 Safari/604.1"

def app_access() -> bool:
    url = "https://mnet.su.ocean.com/captiveportal/api/v1/pcaAppDownload/usr/appValidAccess"
    headers = {
        "accept": "application/json",
        "accept-language": "en",
        "apicaller": "3",
        "content-type": "application/json",
        "origin": "https://mnet.su.ocean.com",
        "priority": "u=1, i", 
        "referer": "https://mnet.su.ocean.com/MednetWifiWeb/plan",
        "sec-fetch-dest": "empty",
        "sec-fetch-mode": "cors",
        "sec-fetch-site": "same-origin",
        "sec-gpc": "1",
        "user-agent": USER_AGENT
    }
    data = {
        "bookingId": BOOKING_ID
    }
    response = requests.post(url, headers=headers, json=data)
    try:
        pprint(response.json())
        if response.json()["isTimeRemaining"] is False:
            return True
    except Exception as e:
        pprint({"error getting internet access via app download method": str(e)})
        return 
        
    # Make a simple request to https://play.google.com or apple app store
    time.sleep(5)  # Small delay since I don't think it gives access immediately
    try:
        url = "https://apps.apple.com/us/app/princess-cruises/id6469049279"
        # url = "https://play.google.com"
        headers = {
            "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
            "accept-language": "en-US,en;q=0.5",
            "user-agent": USER_AGENT
        }
        response = requests.get(url)
        pprint(
            response.status_code,
            )
    except requests.exceptions.ConnectionError:
        pprint("Couldn't GET app store url, should be fine though")
    return False
def login_user(ship_code: str):
    url = "https://mnet.su.ocean.com/captiveportal/api/v1/loginUser"
    headers = {
        "accept": "application/json",
        "accept-language": "en",
        "apicaller": "3",
        "content-type": "application/json",
        "origin": "https://mnet.su.ocean.com",
        "priority": "u=1, i",
        "referer": "https://mnet.su.ocean.com/MednetWifiWeb/login",
        "sec-fetch-dest": "empty",
        "sec-fetch-mode": "cors",
        "sec-fetch-site": "same-origin",
        "sec-gpc": "1",
        "user-agent":  USER_AGENT
    }
    data = {
        "cabinNumber": ROOM_NUMBER,
        "dob": DOB,
        "clickfromOceanConcierge": False,
        "shipCode": ship_code,
        "tokenType": 1
    }
    response = requests.post(url, headers=headers, json=data)
    # pprint(response.json())

def random_mac_even_first_byte() -> str:
    # Generate a random MAC with even first byte
    first_byte = random.randint(0, 255) & 0xFE
    mac_bytes = [first_byte] + [random.randint(0, 255) for _ in range(5)]
    mac = EUI(':'.join(f"{b:02x}" for b in mac_bytes))
    mac.dialect = mac_unix_expanded
    return str(mac)

def edit_mac(admin_token):
    url = "http://192.168.8.1/cgi-bin/api/router/mac/clone"
    new_mac = random_mac_even_first_byte()  # Use the correct function
    headers = {
        "Accept": "application/json, text/javascript, */*; q=0.01",
        "Accept-Language": "en-US,en;q=0.8",
        "Authorization": admin_token,
        "Connection": "keep-alive",
        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
        "Origin": "http://192.168.8.1",
        "Referer": "http://192.168.8.1/",
        "Sec-GPC": "1",
        # "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36",
        "User-Agent": USER_AGENT,
        "X-Requested-With": "XMLHttpRequest"
    }
    cookies = {
        "Admin-Token": admin_token
    }
    data = {
        "newmac": new_mac
    }
    response = requests.post(url, headers=headers, cookies=cookies, data=data, verify=False)
    pprint({"new_mac": new_mac, "response": response.json()})
    return response.json()

def login_router(password):
    """
    Logs into the router and returns the Admin-Token.
    """
    url = "http://192.168.8.1/cgi-bin/api/router/login"
    headers = {
        "Accept": "application/json, text/javascript, */*; q=0.01",
        "Accept-Language": "en-US,en;q=0.8",
        "Authorization": "undefined",
        "Connection": "keep-alive",
        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
        "Origin": "http://192.168.8.1",
        "Referer": "http://192.168.8.1/",
        "Sec-GPC": "1",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36",
        "X-Requested-With": "XMLHttpRequest"
    }
    data = {
        "pwd": password
    }
    response = requests.post(url, headers=headers, data=data, verify=False)
    # pprint({"status_code": response.status_code})
    # pprint({"headers": dict(response.headers)})
    # pprint({"cookies": response.cookies.get_dict()})
    try:
        token = response.json().get("token")
        # pprint({"login_router_response": response.json(), "Admin-Token": token})
        return token
    except Exception as e:
        pprint({"error": str(e)})
        return None

def can_connect_to_example() -> bool:
    try:
        requests.get("https://example.com", timeout=5)
        return True
    except requests.RequestException:
        return False
    
def get_ship_code() -> str:
    # https://mnet.su.ocean.com/captiveportal/api/v1/shipcodes/ship
    # {"shipCodesMapping":[{"shipCode":"SU","shipName":"Sun Princess"}]}
    url = "https://mnet.su.ocean.com/captiveportal/api/v1/shipcodes/ship"
    headers = {
        "accept": "application/json",
        "accept-language": "en",
        "content-type": "application/json",
        "user-agent": USER_AGENT
    }
    response = requests.get(url, headers=headers)
    try:
        ship_code = response.json()["shipCodesMapping"][0]["shipCode"]
        return ship_code
    except Exception as e:
        pprint({"error getting ship code, defaulting to SU for Sun Princess": str(e)})
        return "SU"

def connect_to_internet(ship_code: str):
    while True: # Loop until we get internet access
        while True: # Loop until we get any response from the app internet request
            while True: # Loop until we successfully login
                print("Logging in")
                try:
                    login_user(ship_code=ship_code)
                except requests.exceptions.ConnectionError:
                    print("Couldn't connect to login page, sleeping for 2 seconds and retrying")
                    time.sleep(2)
                    continue
                else:
                    break
            print("Requesting app internet")
            try:
                # Don't regen mac unless this returns true
                print("Randomizing MAC due to session expiration") 
                regen_mac = app_access()
            except requests.exceptions.ConnectionError:
                print("Couldn't get app internet, sleeping for 2 seconds and retrying")
                time.sleep(2)
                continue
            else:
                break
        if regen_mac:
            edit_mac(login_router(PASSWORD))
            # time.sleep(3)
        else:
            break

def main():
    print("hi")
    ship_code = get_ship_code()
    while True:
        if can_connect_to_example():
            print("Internet access detected (can connect to example.com). Waiting 15 seconds before checking again.")
            time.sleep(15)
            continue
        else:
            print("Cannot connect to example.com, attempting to activate a 15 minute free cruise internet session")
        connect_to_internet(ship_code=ship_code)
        print(f"Finished at {time.strftime('%H:%M:%S')}, but sleeping for 30 seconds before verifying internet access")
        time.sleep(30) # Sleep for 30 seconds before checking again since it might take a while for internet access to be granted

if __name__ == "__main__":
    main()