def check_result(result):
if result is None:
return Verdict.DOWN("network error", "network error")
if not result.is_success:
return Verdict.MUMBLE(
"unexpected result",
"request finished with code {}".format(result.code))
return None
def put_note_flag(host: str, flag_id: str, flag: str) -> Verdict:
try:
with build_session() as session:
api = Api(host, session)
user = Randomizer.user()
resp = api.register_user(user)
if resp.status_code != 201:
return Verdict.MUMBLE("Can't register user", "Can't register user")
resp = api.create_note(flag, False)
if resp.status_code != 201:
return Verdict.MUMBLE("Can't create note", "Can't create note")
return Verdict.OK(f"{user['login']}:{user['pwd']}")
except Exception as e:
return Verdict.DOWN("Can't connect to service", str(e))
def get_zip_flag(host: str, flag_id: str, flag: str) -> Verdict:
try:
with build_session() as session:
api = Api(host, session)
l, p = flag_id.split(':')
user = {'login': l, 'pwd': p}
resp = api.register_user(user)
if resp.status_code != 201:
return Verdict.MUMBLE("Can't login", "Can't login")
resp = api.search_file(flag)
if flag not in resp.text:
return Verdict.CORRUPT("Can't find flag", "Can't find flag from zip")
return Verdict.OK()
except Exception as e:
return Verdict.DOWN("Can't connect to service", str(e))
async def check(host: str) -> Verdict:
password = generate_random_string()
src_name = generate_random_string()
message = generate_random_string()
result = rustClient.create_source(src_name, password, False, host)
check_res = check_result(result)
if check_res is not None:
return check_res
token = result.result
push_result = rustClient.push_to_source(src_name, password, message, host)
check_res = check_result(push_result)
if check_res is not None:
return check_res
fl = True
subscribe_req = notificationApiClient.create_subscribe_on_source_request(
src_name, token)
# print(subscribe_req)
async with sse_client.EventSource(subscribe_req) as event_source:
try:
async for event in event_source:
decode_result = get_flag_from_base64(event.data)
if decode_result is None:
continue
if message in decode_result.upper():
fl = False
# print(decode_result)
break
except Exception as e:
return Verdict.DOWN("network error", "network error")
if fl:
return Verdict.CORRUPT("flag not found", "flag not found")
get_sources_list_result = rustClient.get_sources_list(host)
check_res = check_result(get_sources_list_result)
if check_res is not None:
return check_res
print(1)
return Verdict.OK()
async def get_flag(host: str, flag_id: str, flag: str) -> Verdict:
parts = flag_id.split(':')
token = parts[1]
flag_id = parts[0]
subscribe_req = notificationApiClient.create_subscribe_on_source_request(
flag_id, token)
async with sse_client.EventSource(subscribe_req) as event_source:
try:
async for event in event_source:
decode_result = get_flag_from_base64(event.data)
if decode_result is None:
continue
if flag in decode_result.upper():
return Verdict.OK()
except Exception as e:
return Verdict.DOWN("network error", "network error")
return Verdict.CORRUPT("flag not found", "flag not found")
def on_get(team_ip: str, flag_id: str, flag: str) -> Verdict:
user, password = generator.generate_userpass(flag_id)[0]
try:
cookie = beacons_api.sign_in(team_ip, user, password)
except requests.exceptions.ConnectionError:
return Verdict.DOWN('down', 'ConnectionError')
if not cookie:
return Verdict.MUMBLE('', "no session cookie, can't sign in")
beacons = beacons_api.get_all_user_beacons(team_ip, cookie)
if not beacons:
return Verdict.MUMBLE('', 'no beacon')
comments = []
for id in beacons:
comments.append(beacons_api.get_beacon_comment(team_ip, cookie, id))
if flag in comments:
# print(comments)
# print(flag)
return Verdict.OK()
return Verdict.CORRUPT('', 'hz')
def check_service(host: str) -> Verdict:
try:
with build_session() as session:
api = Api(host, session)
resp = api.register_user(Randomizer.user())
if resp.status_code != 201:
return Verdict.MUMBLE("Can't register user", "Can't register user")
file_in_zip, *file = create_zip()
resp = api.upload_zip(file)
if resp.status_code != 202:
return Verdict.MUMBLE("Can't upload file", "Can't upload file")
resp = api.search_file(file_in_zip)
if file_in_zip not in resp.text:
return Verdict.MUMBLE("Can't find file from zip", "Can't find file from zip")
resp = api.create_note(get_text(), True)
if resp.status_code != 201:
return Verdict.MUMBLE("Can't create note", "Can't create note")
return Verdict.OK()
except Exception as e:
return Verdict.DOWN("Can't connect to service", str(e))
def on_put(team_ip: str, flag_id: str, flag: str) -> Verdict:
global STATES
# print('\nputting')
for i in range(6):
try:
user, password = generator.generate_userpass(flag_id)[0]
session = beacons_api.register_user(team_ip, user, password)
except requests.exceptions.ConnectionError:
return Verdict.DOWN('down', 'ConnectionError')
if session:
break
if i == 5:
return Verdict.MUMBLE("Can;t register user", '')
beacon_name = generator.generate_beacon_name()
for i in range(7):
x, y = generator.generate_coords()
beacon_id = beacons_api.add_beacon(team_ip, session, x, y, beacon_name,
flag)
if beacon_id:
return Verdict.OK()
return Verdict.MUMBLE("Can't add new beacon", '')
def put_flag_into_the_service(host: str, flag_id: str, flag: str) -> Verdict:
password = generate_random_string()
result = rustClient.create_source(flag_id, password, False, host)
check_res = check_result(result)
if check_res is not None:
return check_res
token = result.result
push_result = rustClient.push_to_source(flag_id, password, flag, host)
check_res = check_result(push_result)
if check_res is not None:
return check_res
# print('{}:{}'.format(flag_id, token))
return Verdict.OK('{}:{}'.format(flag_id, token))
def on_check(team_ip: str) -> Verdict:
private_result = False
public_result = False
sharing_result = False
# check adding pictures, sharing links and devices
image_name = generator.get_image()
try:
for i in range(6):
user, password = generator.generate_userpass(None)[0]
cookie = beacons_api.register_user(team_ip, user, password)
if cookie:
break
if i == 5:
return Verdict.MUMBLE("Can't register new user",
"Can't register new user")
except requests.exceptions.ConnectionError:
return Verdict.DOWN('down', 'ConnectionError')
# могжет не подойти название, коммент или координаты оказаться использованными
for i in range(5):
name = generator.generate_beacon_name()
private_x, private_y = generator.generate_coords()
x, y = generator.generate_coords()
private_comment = generator.generate_comment()
public_comment = generator.generate_comment()
beacon_id_private = beacons_api.add_beacon(team_ip, cookie, private_x,
private_y, name,
private_comment)
beacon_id_public = beacons_api.add_beacon(team_ip, cookie, x, y, name,
public_comment, False)
if beacon_id_private and beacon_id_public:
break
if i == 4:
return Verdict.MUMBLE("Can't add new beacon",
"Can't add new beacon")
invite_code = beacons_api.get_beacon_invite(team_ip, cookie,
beacon_id_private)
if not invite_code:
return Verdict.MUMBLE("Can't get invite code", "Can't get invite code")
image_id_private = beacons_api.upload_image(team_ip, cookie,
beacon_id_private, image_name)
image_id_public = beacons_api.upload_image(team_ip, cookie,
beacon_id_public, image_name)
if not image_id_private or not image_id_public:
return Verdict.MUMBLE("Can't upload image", "Can't upload image")
images = beacons_api.get_image_ids(team_ip, cookie, beacon_id_private)
if image_id_private in [img['id'] for img in images]:
# print(1)
private_result = True
logout = beacons_api.logout(team_ip, cookie)
if logout != 200:
return Verdict.MUMBLE('no logout', 'no logout')
# check availability of public image
for i in range(4):
new_user, new_pass = generator.generate_userpass(None)[0]
another_user_cookie = beacons_api.register_user(
team_ip, new_user, new_pass)
if another_user_cookie:
break
if i == 3:
return Verdict.MUMBLE("Can't register user", "Can't register user")
images = beacons_api.get_image_ids(team_ip, another_user_cookie,
beacon_id_public)
if image_id_public in [img['id'] for img in images]:
# print(2)
public_result = True
# check the possibility to get shared beacons
is_private = beacons_api.get_shared_beacon(team_ip, another_user_cookie,
invite_code)
if not is_private:
# print(3)
sharing_result = True
logout = beacons_api.logout(team_ip, another_user_cookie)
if logout != 200:
return Verdict.MUMBLE('no logout', 'no logout')
if private_result and public_result and sharing_result:
return Verdict.OK()
return Verdict.MUMBLE("Can't get images", "Can't get images")