async def main():
keys = KeySet.load(PATH_KEYS)
info = ProdInfo(keys, PATH_PRODINFO)
with open(PATH_TICKET, "rb") as f:
ticket = f.read()
cert = info.get_tls_cert()
pkey = info.get_tls_key()
dauth = DAuthClient(keys)
dauth.set_certificate(cert, pkey)
dauth.set_system_version(SYSTEM_VERSION)
response = await dauth.device_token(dauth.BAAS)
device_token = response["device_auth_token"]
aauth = AAuthClient()
aauth.set_system_version(SYSTEM_VERSION)
response = await aauth.auth_digital(SMM2.TITLE_ID, SMM2.LATEST_VERSION,
device_token, ticket)
app_token = response["application_auth_token"]
baas = BAASClient()
baas.set_system_version(SYSTEM_VERSION)
response = await baas.authenticate(device_token)
access_token = response["accessToken"]
response = await baas.login(BAAS_USER_ID, BAAS_PASSWORD, access_token,
app_token)
user_id = int(response["user"]["id"], 16)
id_token = response["idToken"]
auth_info = authentication.AuthenticationInfo()
auth_info.token = id_token
auth_info.ngs_version = 4 #Switch
auth_info.token_type = 2
s = settings.load("switch")
s.configure(SMM2.ACCESS_KEY, SMM2.NEX_VERSION, SMM2.CLIENT_VERSION)
async with backend.connect(s, HOST, PORT) as be:
async with be.login(str(user_id), auth_info=auth_info) as client:
# Search for ninji courses
store = datastore.DataStoreClientSMM2(client)
param = datastore.SearchCoursesEventParam()
courses = await store.search_courses_event(param)
print("Found %i ninji courses.\n" % len(courses))
# Print information about the oldest ninji course
course = courses[-1]
print("Name:", course.name)
print("Description:", course.description)
print("Start time:", course.upload_time)
print("End time:", course.end_time)
print()
# Request ghost info
param = datastore.GetEventCourseGhostParam()
param.data_id = course.data_id
param.time = 30000 # Request ghosts with a time around 30 seconds
param.count = 1 # Only request a single ghost
ghost = (await store.get_event_course_ghost(param))[0]
# Request info about the ghost player
param = datastore.GetUsersParam()
param.pids = [ghost.pid]
user = (await store.get_users(param)).users[0]
print("Player:", user.name)
print("Time: %i.%03i" % (ghost.time // 1000, ghost.time % 1000))
print()
# Download replay file
header_info = await store.get_req_get_info_headers_info(
ghost.replay_file.data_type)
headers = {h.key: h.value for h in header_info.headers}
response = await http.get(ghost.replay_file.url, headers=headers)
response.raise_if_error()
# Decompress and save replay file
data = zlib.decompress(response.body)
with open("replay.bin", "wb") as f:
f.write(data)
# su/baas/<guid>.dat in save folder 8000000000000010.
# Bytes 0x20 - 0x28 contain the user id in reversed
# byte order, and bytes 0x28 - 0x50 contain the
# password in plain text.
# Alternatively, you can set up a mitm on your Switch
# and extract them from the request to /1.0.0/login
BAAS_USER_ID = 0x0123456789abcdef # 16 hex digits
BAAS_PASSWORD = "******" # Should be 40 characters
# You can dump prod.keys with Lockpick_RCM and
# PRODINFO from hekate (decrypt it if necessary)
keys = KeySet("/path/to/prod.keys")
info = ProdInfo(keys, "/path/to/PRODINFO")
# Tickets can be dumped with nxdumptool.
# You need the base ticket, not an update ticket.
# Do not remove console specific data.
with open("/path/to/ticket", "rb") as f:
ticket = f.read()
HOST = "g%08x-lp1.s.n.srv.nintendo.net" % SMM2.GAME_SERVER_ID
PORT = 443
ticket = tickets.get(SMM2.TITLE_ID)
cert = info.get_ssl_cert()
pkey = info.get_ssl_key()
async def main():
keys = KeySet.load(PATH_KEYS)
info = ProdInfo(keys, PATH_PRODINFO)
with open(PATH_TICKET, "rb") as f:
ticket = f.read()
cert = info.get_tls_cert()
pkey = info.get_tls_key()
dauth = DAuthClient(keys)
dauth.set_certificate(cert, pkey)
dauth.set_system_version(SYSTEM_VERSION)
response = await dauth.device_token(dauth.BAAS)
device_token = response["device_auth_token"]
aauth = AAuthClient()
aauth.set_system_version(SYSTEM_VERSION)
response = await aauth.auth_digital(GBG.TITLE_ID, GBG.LATEST_VERSION,
device_token, ticket)
app_token = response["application_auth_token"]
baas = BAASClient()
baas.set_system_version(SYSTEM_VERSION)
response = await baas.authenticate(device_token)
access_token = response["accessToken"]
response = await baas.login(BAAS_USER_ID, BAAS_PASSWORD, access_token,
app_token)
user_id = int(response["user"]["id"], 16)
id_token = response["idToken"]
auth_info = authentication.AuthenticationInfo()
auth_info.token = id_token
auth_info.ngs_version = 4 #Switch
auth_info.token_type = 2
s = settings.load("switch")
s.configure(GBG.ACCESS_KEY, GBG.NEX_VERSION, GBG.CLIENT_VERSION)
async with backend.connect(s, HOST, PORT) as be:
async with be.login(str(user_id), auth_info=auth_info) as client:
store = datastore.DataStoreClient(client)
# Request meta data
param = datastore.DataStoreGetMetaParam()
param.data_id = code_to_data_id(GAME_CODE)
meta = await store.get_meta(param)
print("Data id:", meta.data_id)
print("Owner id:", meta.owner_id)
print("Uploaded at:", meta.create_time)
print("Expires at:", meta.expire_time)
# Download game file
result = await store.get_object_infos([meta.data_id])
result.results[0].raise_if_error()
info = result.infos[0]
url = "https://" + info.url
headers = {h.key: h.value for h in info.headers}
response = await http.get(url, headers=headers)
response.raise_if_error()
with open("game.bin", "wb") as f:
f.write(response.body)
async def main():
keys = KeySet.load(PATH_KEYS)
info = ProdInfo(keys, PATH_PRODINFO)
with open(PATH_TICKET, "rb") as f:
ticket = f.read()
cert = info.get_tls_cert()
pkey = info.get_tls_key()
dauth = DAuthClient(keys)
dauth.set_certificate(cert, pkey)
dauth.set_system_version(SYSTEM_VERSION)
response = await dauth.device_token(dauth.BAAS)
device_token = response["device_auth_token"]
aauth = AAuthClient()
aauth.set_system_version(SYSTEM_VERSION)
response = await aauth.auth_digital(ACNH.TITLE_ID, ACNH.LATEST_VERSION,
device_token, ticket)
app_token = response["application_auth_token"]
baas = BAASClient()
baas.set_system_version(SYSTEM_VERSION)
response = await baas.authenticate(device_token)
access_token = response["accessToken"]
response = await baas.login(BAAS_USER_ID, BAAS_PASSWORD, access_token,
app_token)
user_id = int(response["user"]["id"], 16)
id_token = response["idToken"]
auth_info = authentication.AuthenticationInfo()
auth_info.token = id_token
auth_info.ngs_version = 4 #Switch
auth_info.token_type = 2
s = settings.load("switch")
s.configure(ACNH.ACCESS_KEY, ACNH.NEX_VERSION, ACNH.CLIENT_VERSION)
async with backend.connect(s, HOST, PORT) as be:
async with be.login(str(user_id), auth_info=auth_info) as client:
mm = matchmaking.MatchmakeExtensionClient(client)
param = matchmaking.MatchmakeSessionSearchCriteria()
param.attribs = ["", "", "", "", "", ""]
param.game_mode = "2"
param.min_participants = "1"
param.max_participants = "1,8"
param.matchmake_system = "1"
param.vacant_only = False
param.exclude_locked = True
param.exclude_non_host_pid = True
param.selection_method = 0
param.vacant_participants = 1
param.exclude_user_password = True
param.exclude_system_password = True
param.refer_gid = 0
param.codeword = CODE
sessions = await mm.browse_matchmake_session_no_holder_no_result_range(
param)
if not sessions:
print("\nNo island found for '%s'\n" % CODE)
else:
session = sessions[0]
data = session.application_data
print("\nFound island:")
print("\tId:", session.id)
print("\tActive players:", session.participation_count)
print("\tIsland name:",
data[12:32].decode("utf16").rstrip("\0"))
print("\tHost name:", data[40:60].decode("utf16").rstrip("\0"))
print()
async def main():
keys = KeySet.load(PATH_KEYS)
info = ProdInfo(keys, PATH_PRODINFO)
with open(PATH_TICKET, "rb") as f:
ticket = f.read()
cert = info.get_tls_cert()
pkey = info.get_tls_key()
dauth = DAuthClient(keys)
dauth.set_certificate(cert, pkey)
dauth.set_system_version(SYSTEM_VERSION)
response = await dauth.device_token(dauth.BAAS)
device_token = response["device_auth_token"]
aauth = AAuthClient()
aauth.set_system_version(SYSTEM_VERSION)
response = await aauth.auth_digital(SMM2.TITLE_ID, SMM2.LATEST_VERSION,
device_token, ticket)
app_token = response["application_auth_token"]
baas = BAASClient()
baas.set_system_version(SYSTEM_VERSION)
response = await baas.authenticate(device_token)
access_token = response["accessToken"]
response = await baas.login(BAAS_USER_ID, BAAS_PASSWORD, access_token,
app_token)
user_id = int(response["user"]["id"], 16)
id_token = response["idToken"]
auth_info = authentication.AuthenticationInfo()
auth_info.token = id_token
auth_info.ngs_version = 4 #Switch
auth_info.token_type = 2
s = settings.load("switch")
s.configure(SMM2.ACCESS_KEY, SMM2.NEX_VERSION, SMM2.CLIENT_VERSION)
async with backend.connect(s, HOST, PORT) as be:
async with be.login(str(user_id), auth_info=auth_info) as client:
store = datastore.DataStoreClientSMM2(client)
param = datastore.GetUserOrCourseParam()
param.code = COURSE_ID
param.course_option = datastore.CourseOption.ALL
response = await store.get_user_or_course(param)
course = response.course
# Print information about the course
print("Level info:")
print("\tName:", course.name)
print("\tDescription:", course.description)
print("\tUploaded at:", course.upload_time)
print("\tGame:", GameStyles[course.game_style])
print("\tTheme:", CourseThemes[course.course_theme])
print("\tDifficulty:", Difficulties[course.difficulty])
print("\tFirst tag:", TagNames[course.tag1])
print("\tSecond tag:", TagNames[course.tag2])
print("\tWorld record:",
format_time(course.time_stats.world_record))
print("\tNumber of comments:", course.comment_stats[0])
# Request information about its uploader
param = datastore.GetUsersParam()
param.pids = [course.owner_id]
response = await store.get_users(param)
user = response.users[0]
print("Uploader:")
print("\tCode:", user.code)
print("\tName:", user.name)
print("\tCountry:", user.country)
print("\tLast active:", user.last_active)
# Download thumbnails
await download_thumbnail(store, course.one_screen_thumbnail,
"thumbnail_onescreen.jpg")
await download_thumbnail(store, course.entire_thumbnail,
"thumbnail_entire.jpg")
# Download level file
param = datastore.DataStorePrepareGetParam()
param.data_id = course.data_id
req_info = await store.prepare_get_object(param)
response = await http.get(req_info.url)
response.raise_if_error()
with open("level.bin", "wb") as f:
f.write(response.body)