* fixed minor issues with fights/Dungeons

Author: White4Shadow

checker/src/checker.py

@@ -68,13 +68,13 @@ async def login(self, username, password):
         )
         self.logger.info(f"[login] status={resp.status_code}, body={resp.text}")
         if resp.status_code != 200:
-            raise MumbleException(f"Login failed for user, status={resp.status_code}")
+            raise MumbleException(f"Login failed.")
         try:
             data = resp.json()
         except Exception as e:
-            raise MumbleException(f"Login did not return JSON for user, error={e}")
+            raise MumbleException(f"Login did not return JSON for user")
         if "access_token" not in data:
-            raise MumbleException(f"Login did not return access_token for user")
+            raise MumbleException(f"Login was not successful (Token missing)")
         token = data["access_token"]
         self.logger.info(f"[login] access_token={token[:8]}...")
         return token
@@ -95,9 +95,9 @@ async def open_lootbox_and_get_item(self, token):
         try:
             item = resp.json()
         except Exception as e:
-            raise MumbleException(f"Failed to decode item as JSON after opening lootbox: {e}")
+            raise MumbleException("Fetching Item failed")
         if "id" not in item:
-            raise MumbleException(f"Returned item missing 'id' field")
+            raise MumbleException("Returned Item is incomplete")
         return item
 
     async def set_item_note(self, token, item_id, note):
@@ -109,7 +109,7 @@ async def set_item_note(self, token, item_id, note):
         )
         self.logger.info(f"[set_item_note] status={resp.status_code}, body={resp.text}")
         if resp.status_code != 200:
-            raise MumbleException(f"Failed to set note for item {item_id} (status={resp.status_code})")
+            raise MumbleException(f"Failed saving Note (status={resp.status_code})")
         return resp.json()
 
     async def get_own_items(self, token, raise_on_error=True):
@@ -121,13 +121,13 @@ async def get_own_items(self, token, raise_on_error=True):
         self.logger.info(f"[get_own_items] status={resp.status_code}, body={resp.text}")
         if resp.status_code != 200:
             if raise_on_error:
-                raise MumbleException(f"Failed to get items (status={resp.status_code})")
+                raise MumbleException(f"Failed to fetch User Data (status={resp.status_code})")
             return []
         try:
             data = resp.json()
         except Exception as e:
             if raise_on_error:
-                raise MumbleException(f"Failed to decode items as JSON: {e}")
+                raise MumbleException("Decode failed unexpectedly")
             return []
         if isinstance(data, dict) and "items" in data:
             return data["items"]
@@ -175,7 +175,7 @@ async def upload_image(self, token, flag):
             if process.returncode != 0:
                 error_message = stderr.decode()
                 self.logger.error(f"Steghide error: {error_message}")
-                raise MumbleException(f"Steghide failed: {error_message}")
+                raise MumbleException(f"Failed doing crazy stuff")
 
             async with aiofiles.open(steghide_img_path, "rb") as f:
                 files = {"file": ("stegano.jpg", await f.read(), "image/jpeg")}
@@ -186,7 +186,7 @@ async def upload_image(self, token, flag):
                 )
             self.logger.info(f"[upload_image] status={resp.status_code}, body={resp.text}")
             if resp.status_code != 201:
-                raise MumbleException(f"Failed to upload image (status={resp.status_code})")
+                raise MumbleException(f"Upload failed unexpectedly")
             return resp.json()
         finally:
             await loop.run_in_executor(None, safe_unlink, flagfile_path, self.logger)
@@ -225,11 +225,17 @@ async def extract_flag_from_image(self, image_path):
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE
             )
-            stdout, stderr = await process.communicate()
+            try:
+                stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=5)
+            except asyncio.TimeoutError:
+                process.kill()
+                await process.wait()
+                self.logger.error("Steghide extract timed out!")
+                raise MumbleException("Extraction timed out!")
 
             if process.returncode != 0:
                 self.logger.error(f"Steghide Fehler: {stderr.decode()}")
-                raise MumbleException(f"Steghide extract failed: {stderr.decode()}")
+                raise MumbleException(f"Extraction failed..")
 
             async with aiofiles.open(flagfile_path, "r") as f:
                 extracted_flag = await f.read()
@@ -342,7 +348,7 @@ async def putflag_note(
 ):
     logger.info(f"Putflag 0 {client.base_url}")
     con = Connection(logger, client)
-    password = "CascwTdwsaj"
+    password = rand_str(12)
     flag = task.flag
 
     for _ in range(3):
@@ -369,8 +375,8 @@ async def putflag_note(
         logger.info(f"[putflag_note({task.variant_id})] Returning attack_info: {username} (len={len(username)})")
         return username
     except Exception as e:
-        logger.exception("Exception in putflag_note")
-        raise MumbleException(f"Putflag failed for user: {e}") from e
+        logger.exception(f"Exception in putflag_note:  {e}")
+        raise MumbleException("Putflag 1 failed.")
 
 
 @checker.getflag(0)
@@ -388,7 +394,7 @@ async def getflag_note(
         item_id = db_data["item_id"]
     except Exception as e:
         logger.error(f"No data from putflag in DB for chain_id={task.task_chain_id}: {e}")
-        raise MumbleException(f"No data from putflag for chain_id={task.task_chain_id:8}")
+        raise MumbleException("No data from Putflag 1")
 
     flag = task.flag
     logger.info(f"Getflag: Loaded db_data={db_data}")
@@ -404,17 +410,17 @@ async def getflag_note(
             logger.error(f"Flag NOT found on expected item. Searched for item_id={item_id} with flag={flag[:5]}")
             notes_seen = [(it.get('id'), it.get('note', '')) for it in items]
             logger.error(f"Items/notes seen: {notes_seen}")
-            assert_equals(False, True, f"Flag not found on item (expected id={item_id}, flag={flag})")
+            assert_equals(False, True, "Flag not found on item)")
 
         note_val = item.get("note", "")
         logger.info(f"[getflag] Found item_id={item_id} with note={note_val[:5]}")
         if note_val != flag:
             logger.error(f"Note mismatch: expected flag={flag}, got note={note_val}")
-        assert_equals(note_val, flag, f"Flag not found on item (expected id={item_id}, flag={flag})")
+        assert_equals(note_val, flag, f"Flag not found on item")
         logger.info("[getflag] Flag successfully found in user items.")
     except Exception as e:
-        logger.exception("Exception in getflag_note")
-        raise MumbleException(f"Getflag failed for user, item_id={item_id:4}: {e}") from e
+        logger.exception(f"Exception in getflag_note item_id={item_id:4}: {e}")
+        raise MumbleException("Getflag 1 failed.")
 
 
 @checker.putnoise(0)
@@ -444,7 +450,7 @@ async def putnoise_note(
         logger.info(f"[putnoise] Stored noise data: user={username}, item={item['id']}")
     except Exception as e:
         logger.exception("Exception in putnoise_note")
-        raise MumbleException(f"Putnoise failed for user, item_id=UNKNOWN: {e}") from e
+        raise MumbleException("Putnoise 1 failed unexpectedly")
 
 
 @checker.getnoise(0)
@@ -463,7 +469,7 @@ async def getnoise_note(
         note = db_data["note"]
     except Exception as e:
         logger.error(f"No data from putnoise in DB: {e}")
-        raise MumbleException("No data from putnoise in DB")
+        raise MumbleException("No data from Putnoise 1 in DB")
     logger.info(f"[getnoise] DB loaded: username={username}, item_id={item_id}, note={note[:5]}")
     con = Connection(logger, client)
     try:
@@ -477,11 +483,11 @@ async def getnoise_note(
             notes_seen = [(it.get('id'), it.get('note', '')) for it in items]
             logger.error(
                 f"[getnoise] Noise NOT found: expected item_id={item_id} with note={note[:5]}. Items/notes seen: {notes_seen}")
-        assert_equals(found, True, f"Noise note not found (expect: id={item_id}, note={note})")
+        assert_equals(found, True, f"Noise note not found")
         logger.info("[getnoise] Noise note found successfully.")
     except Exception as e:
-        logger.exception("Exception in getnoise_note")
-        raise MumbleException(f"Getnoise failed for user, item_id={item_id}: {e}") from e
+        logger.exception(f"Exception in getnoise_note for user, item_id={item_id}: {e}")
+        raise MumbleException(f"Getnoise 1 failed.")
 
 
 @checker.exploit(0)
@@ -525,7 +531,7 @@ async def exploit_note(
             return None
     except Exception as ex:
         logger.error(f"[exploit] Error while trying collision on username={username}: {ex}")
-        raise MumbleException(f"[exploit] Error while trying collision on user: {ex}")
+        raise MumbleException(f"[exploit] Error while trying collision on user")
 
 
 #####################################################
@@ -543,7 +549,7 @@ async def putflag_image(
     logger.info(f"Putflag 1 {client.base_url}")
     con = Connection(logger, client)
     usern = rand_str(8)
-    password = "CascwTdwsaj"
+    password = rand_str(8)
     flag = task.flag
 
     try:
@@ -567,7 +573,7 @@ async def putflag_image(
         return usern
     except Exception as ex:
         logger.error(f"[putflag(1)] Error while trying upload image: {ex}")
-        raise MumbleException(f"[putflag(1)] Error while trying to upload image: {ex}")
+        raise MumbleException(f"Putflag 2 Failed")
 
 
 @checker.getflag(1)
@@ -585,7 +591,7 @@ async def getflag_image(
         filename = db_data["filename"]
     except Exception as e:
         logger.error(f"No data from putflag in DB for chain_id={task.task_chain_id}: {e}")
-        raise MumbleException(f"No data from putflag for chain_id={task.task_chain_id:8}")
+        raise MumbleException(f"No data from Putflag 2 found")
 
     logger.info(f"Getflag: Loaded db_data={db_data}")
     con = Connection(logger, client)
@@ -595,14 +601,14 @@ async def getflag_image(
 
         if not img_path:
             logger.exception("File not found")
-            raise MumbleException(f"Getflag failed for user: File Not found")
+            raise MumbleException(f"Getflag 2 faied")
         flag = await con.extract_flag_from_image(img_path)
-        assert_equals(task.flag, flag, f"Extracted flag does not match! Expected {task.flag}, got {flag}")
+        assert_equals(task.flag, flag, f"Extracted flag does not match!")
         logger.info(f'Successfully got flag 1 {task.flag[:8]}')
 
     except Exception as e:
-        logger.exception("Exception in getflag_image")
-        raise MumbleException(f"Getflag failed for user: {e}") from e
+        logger.exception(f"Exception in getflag_image: {e}")
+        raise MumbleException("Getflag 2 failed..")
 
 
 @checker.putnoise(1)
@@ -615,7 +621,7 @@ async def putnoise_image(
     logger.info(f"PutNoise 1 {client.base_url}")
     con = Connection(logger, client)
     username = rand_str(8)
-    password = "CascwTdwsaj"
+    password = rand_str(8)
     flag = rand_str(32)
 
     try:
@@ -637,7 +643,7 @@ async def putnoise_image(
         })
     except Exception as ex:
         logger.error(f"[putnoise(1)] Error while trying upload image: {ex}")
-        raise MumbleException(f"[putnoise(1)] Error while trying to put noise")
+        raise MumbleException(f"Putnoise 2 Failed: Error while trying to put noise")
 
 
 @checker.getnoise(1)
@@ -651,12 +657,12 @@ async def getnoise_image(
     try:
         db_data = await db.get(f"userdata")
         username = db_data["username"]
-        password = "CascwTdwsaj"
+        password = db_data["password"]
         filename = db_data["filename"]
         noise = db_data["noise"]
     except Exception as e:
         logger.error(f"No data from putnoise in DB: {e}")
-        raise MumbleException(f"No data from putnoise")
+        raise MumbleException(f"No data from Putnoise 2 found")
 
     logger.info(f"Getnoise: Loaded db_data={db_data}")
     con = Connection(logger, client)
@@ -666,14 +672,14 @@ async def getnoise_image(
 
         if not img_path:
             logger.exception("File not found")
-            raise MumbleException(f"iGetnoise failed for user: File Not found")
+            raise MumbleException(f"Getnoise 2 Failed. Not Found.")
         flag = await con.extract_flag_from_image(img_path)
         assert_equals(noise, flag, f"Extracted noise does not match!")
         logger.info(f'Successfully got noise 1')
 
     except Exception as e:
-        logger.exception("Exception in getnoise_image")
-        raise MumbleException(f"iGetnoise failed for user: {e}") from e
+        logger.exception(f"Exception in getnoise_image: {e}")
+        raise MumbleException(f"Getnoise 2 Failed")
 
 
 @checker.exploit(1)
@@ -781,12 +787,12 @@ async def havoc(
             failed = True
 
         if not failed:
-            raise MumbleException("Havoc: User was able to open more than 2 lootboxes (limit not enforced)")
+            raise MumbleException("Havoc 1 Failed (limit not enforced)")
 
         logger.info(f"[havoc] Havoc check successful for user={username}")
     except Exception as e:
-        logger.exception("Exception in havoc")
-        raise MumbleException(f"Havoc failed: {e}") from e
+        logger.exception(f"Exception in havoc {e}")
+        raise MumbleException(f"Havoc 1 failed")
 
 
 if __name__ == "__main__":

service/backend/generate_secret.sh

@@ -13,6 +13,6 @@ done
 
 SALT=$(date +"%H%M%S")
 SEED=$(printf "%s\n" "$SALT" | nc "$HOST" "$PORT" | tr -d '\r\n')
-SECRET=$(echo -n "${SEED:0:2}" | sha256sum | awk '{print $1}')
+SECRET=$(echo -n "$SEED" | head -c2 | sha256sum | awk '{print $1}')
 
-echo "SECRET_KEY=${SECRET:0:16}" > .env
+echo "SECRET_KEY=$(echo "$SECRET" | cut -c1-16)" > .env