removed faker dependency with new fakeid generation

1 files changed, 118 insertions, 66 deletions

diff --git a/checker/src/checker.py b/checker/src/checker.py
index 2821d2f..795aa69 100644
--- a/checker/src/checker.py
+++ b/checker/src/checker.py
@@ -10,7 +10,6 @@ import subprocess
 
 import numpy as np
 
-logging.getLogger("faker").setLevel(logging.WARNING)
 logging.getLogger("_curses").setLevel(logging.CRITICAL)
 
 from asyncio import StreamReader, StreamWriter
@@ -25,23 +24,22 @@ from enochecker3 import (
     Enochecker,
     GetflagCheckerTaskMessage,
     GetnoiseCheckerTaskMessage,
-    HavocCheckerTaskMessage,
     InternalErrorException,
     MumbleException,
     PutflagCheckerTaskMessage,
     PutnoiseCheckerTaskMessage,
 )
 from enochecker3.utils import FlagSearcher, assert_in
-from faker import Faker
 from stl import mesh
 
 rand = random.SystemRandom()
 generic_alphabet = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmopqrstuvwxyz0123456789-+.!"
 script_path = os.path.dirname(os.path.realpath(__file__))
-models_path = f"{script_path}/models"
-extra_models = [
-    f"{models_path}/{path}" for path in os.listdir(models_path) if path.endswith(".stl")
-]
+extra_models = []
+for path in os.listdir(f"{script_path}/models"):
+    if path.endswith(".stl"):
+        extra_models.append(f"{script_path}/models/{path}")
+wordlist = [w for w in open(f"{script_path}/wordlist.txt").read().split() if w != ""]
 prompt = b"\r$ "
 
 search_truncation_payload = b"""
@@ -108,19 +106,36 @@ def includes_any(resp: bytes, targets: list[bytes]) -> bool:
     return False
 
 
+def randbool() -> bool:
+    return rand.randint(0, 1) == 1
+
+
+def leetify(clean: str) -> str:
+    conv = {
+        "O": "0",
+        "l": "1",
+        "I": "1",
+        "Z": "2",
+        "E": "3",
+        "A": "4",
+        "S": "5",
+        "G": "6",
+        "T": "7",
+    }
+    out = [c.upper() if randbool() else c for c in clean.lower()]
+    return "".join([conv[c] if c in conv else c for c in out])
+
+
 def fakeid(havoc: bool = False) -> bytes:
     if havoc:
         idlen = rand.randint(10, 40)
         return bytes([rand.randint(32, 127) for i in range(idlen)])
     else:
-        fake = Faker(["en_US"])
-        idstr = bytes(
-            [c for c in fake.name().replace(" ", "").encode() if c in generic_alphabet][
-                :12
-            ]
-        ).ljust(10, b".")
-        idstr += bytes([rand.choice(generic_alphabet) for i in range(8)])
-        return idstr
+        words = []
+        for i in range(rand.randint(2, 3)):
+            word = rand.choice(wordlist)
+            words.append(leetify(word).encode() if randbool() else word.encode())
+        return b"-".join(words)
 
 
 def fakeids(n: int, havoc: bool = False) -> list[bytes]:
@@ -724,6 +739,7 @@ async def putflag_guest(
     logger = await di.get(LoggerAdapter)
     db = await di.get(ChainDB)
 
+    # Generate a file with flag in solidname and upload it (unregistered, ascii)
     session = await di.get(Session)
     await session.prepare()
     stlfile = genfile(task.flag.encode(), "ascii")
@@ -731,7 +747,7 @@ async def putflag_guest(
     assert modelid is not None
     await session.close()
 
-    await db.set("flag-0-info", (modelname, modelid))
+    await db.set("info", (modelname, modelid))
 
 
 @checker.putflag(1)
@@ -743,6 +759,7 @@ async def putflag_private(
     stlfile = genfile(task.flag.encode(), "bin")
     db = await di.get(ChainDB)
 
+    # Generate a file with flag in solidname and upload it (registered, bin)
     session = await di.get(Session)
     await session.prepare()
     await do_auth(session, logger, authstr, check=True)
@@ -750,7 +767,7 @@ async def putflag_private(
     assert modelid is not None
     await session.close()
 
-    await db.set("flag-1-info", (modelname, modelid, authstr))
+    await db.set("info", (modelname, modelid, authstr))
 
 
 @checker.getflag(0)
@@ -758,9 +775,10 @@ async def getflag_guest(
     task: GetflagCheckerTaskMessage, di: DependencyInjector
 ) -> None:
     db = await di.get(ChainDB)
-    modelname, modelid = await getdb(db, "flag-0-info")
+    modelname, modelid = await getdb(db, "info")
     logger = await di.get(LoggerAdapter)
 
+    # Retrieve flag file info via search and ensure flag's included
     session = await di.get(Session)
     await session.prepare()
     resp = await do_search(session, logger, modelname, download=True, check=True)
@@ -775,9 +793,10 @@ async def getflag_private(
     task: GetflagCheckerTaskMessage, di: DependencyInjector
 ) -> None:
     db = await di.get(ChainDB)
-    modelname, modelid, authstr = await getdb(db, "flag-1-info")
+    modelname, modelid, authstr = await getdb(db, "info")
     logger = await di.get(LoggerAdapter)
 
+    # Retrieve private flag file info via search / list and ensure flag's included
     session = await di.get(Session)
     await session.prepare()
     await do_auth(session, logger, authstr, check=True)
@@ -792,32 +811,32 @@ async def getflag_private(
 
 
 @checker.putnoise(0, 1)
-async def putnoise_guest_ascii(
+async def putnoise_guest(
     task: PutnoiseCheckerTaskMessage, di: DependencyInjector
 ) -> None:
     modelname, solidname = fakeids(2)
     logger = await di.get(LoggerAdapter)
     db = await di.get(ChainDB)
 
+    # Generate a random file and upload it (unregistered, bin / ascii)
     session = await di.get(Session)
     await session.prepare()
     stlfile = genfile(solidname, "ascii" if task.variant_id == 0 else "bin")
     modelid = await do_upload(session, logger, modelname, stlfile, check=True)
     await session.close()
 
-    await db.set(
-        f"noise-{task.variant_id}-info", (modelid, modelname, solidname, stlfile)
-    )
+    await db.set("info", (modelid, modelname, solidname, stlfile))
 
 
 @checker.putnoise(2, 3)
-async def putnoise_priv_ascii(
+async def putnoise_priv(
     task: PutnoiseCheckerTaskMessage, di: DependencyInjector
 ) -> None:
     modelname, solidname, authstr = fakeids(3)
     logger = await di.get(LoggerAdapter)
     db = await di.get(ChainDB)
 
+    # Generate a random file and upload it (registered, bin / ascii)
     session = await di.get(Session)
     await session.prepare()
     stlfile = genfile(solidname, "ascii" if task.variant_id == 0 else "bin")
@@ -825,22 +844,18 @@ async def putnoise_priv_ascii(
     modelid = await do_upload(session, logger, modelname, stlfile, check=True)
     await session.close()
 
-    await db.set(
-        f"noise-{task.variant_id}-info",
-        (modelid, modelname, solidname, stlfile, authstr),
-    )
+    await db.set("info", (modelid, modelname, solidname, stlfile, authstr))
 
 
 @checker.getnoise(0, 1)
-async def getnoise_guest_ascii(
+async def getnoise_guest(
     task: GetnoiseCheckerTaskMessage, di: DependencyInjector
 ) -> None:
     db = await di.get(ChainDB)
-    modelid, modelname, solidname, stlfile = await getdb(
-        db, f"noise-{task.variant_id}-info"
-    )
+    modelid, modelname, solidname, stlfile = await getdb(db, "info")
     logger = await di.get(LoggerAdapter)
 
+    # Retrieve noise file by name via search
     session = await di.get(Session)
     await session.prepare()
     await check_in_search(
@@ -854,15 +869,14 @@ async def getnoise_guest_ascii(
 
 
 @checker.getnoise(2, 3)
-async def getnoise_priv_ascii(
+async def getnoise_priv(
     task: GetnoiseCheckerTaskMessage, di: DependencyInjector
 ) -> None:
     db = await di.get(ChainDB)
-    modelid, modelname, solidname, stlfile, authstr = await getdb(
-        db, f"noise-{task.variant_id}-info"
-    )
+    modelid, modelname, solidname, stlfile, authstr = await getdb(db, "info")
     logger = await di.get(LoggerAdapter)
 
+    # Retrieve noise file by name via search and search (registered)
     session = await di.get(Session)
     await session.prepare()
     await do_auth(session, logger, authstr, check=True)
@@ -873,46 +887,82 @@ async def getnoise_priv_ascii(
         [modelname, solidname, stlfile, modelid],
         download=True,
     )
+    await check_listed(session, logger, [modelname, solidname, modelid])
     await session.close()
 
 
-@checker.havoc(*range(0, 4))
-async def havoc_good_upload(
-    task: HavocCheckerTaskMessage, di: DependencyInjector
-) -> None:
-    filetype = ["ascii", "bin", "ascii", "bin"]
-    registered = [False, False, True, True]
-    await test_good_upload(di, filetype[task.variant_id], registered[task.variant_id])
+@checker.havoc(0)
+async def havoc_good_upload_guest_ascii(di: DependencyInjector) -> None:
+    await test_good_upload(di, filetype="ascii", register=False)
 
 
-@checker.havoc(*range(4, 12))
-async def havoc_bad_upload(
-    task: HavocCheckerTaskMessage, di: DependencyInjector
-) -> None:
-    filetype = [
-        "ascii",
-        "ascii",
-        "ascii",
-        "bin",
-        "bin",
-        "bin",
-        "garbage",
-        "garbage-tiny",
-    ]
-    upload_variant = [1, 2, 3, 1, 2, 3, 1, 1]
-    index = task.variant_id - 4
-    await test_bad_upload(di, filetype[index], upload_variant[index])
+@checker.havoc(1)
+async def havoc_good_upload_guest_bin(di: DependencyInjector) -> None:
+    await test_good_upload(di, filetype="bin", register=False)
 
 
-@checker.havoc(12, 13)
-async def havoc_test_search(
-    task: HavocCheckerTaskMessage, di: DependencyInjector
-) -> None:
-    await test_search(di, task.variant_id == 12)
+@checker.havoc(2)
+async def havoc_good_upload_priv_ascii(di: DependencyInjector) -> None:
+    await test_good_upload(di, filetype="ascii", register=True)
+
+
+@checker.havoc(3)
+async def havoc_good_upload_priv_bin(di: DependencyInjector) -> None:
+    await test_good_upload(di, filetype="bin", register=True)
+
+
+@checker.havoc(4)
+async def havoc_bad_upload_ascii_v1(di: DependencyInjector) -> None:
+    await test_bad_upload(di, "ascii", 1)
+
+
+@checker.havoc(5)
+async def havoc_bad_upload_ascii_v2(di: DependencyInjector) -> None:
+    await test_bad_upload(di, "ascii", 2)
+
+
+@checker.havoc(6)
+async def havoc_bad_upload_ascii_v3(di: DependencyInjector) -> None:
+    await test_bad_upload(di, "ascii", 3)
+
+
+@checker.havoc(7)
+async def havoc_bad_upload_bin_v1(di: DependencyInjector) -> None:
+    await test_bad_upload(di, "bin", 1)
+
+
+@checker.havoc(8)
+async def havoc_bad_upload_bin_v2(di: DependencyInjector) -> None:
+    await test_bad_upload(di, "bin", 2)
+
+
+@checker.havoc(9)
+async def havoc_bad_upload_bin_v3(di: DependencyInjector) -> None:
+    await test_bad_upload(di, "bin", 3)
+
+
+@checker.havoc(10)
+async def havoc_bad_upload_garbage(di: DependencyInjector) -> None:
+    await test_bad_upload(di, "garbage", 1)
+
+
+@checker.havoc(11)
+async def havoc_bad_upload_garbage_tiny(di: DependencyInjector) -> None:
+    await test_bad_upload(di, "garbage-tiny", 1)
+
+
+@checker.havoc(12)
+async def havoc_test_search_guest(di: DependencyInjector) -> None:
+    await test_search(di, registered=False)
+
+
+@checker.havoc(13)
+async def havoc_test_search_priv(di: DependencyInjector) -> None:
+    await test_search(di, registered=True)
 
 
 @checker.havoc(14)
-async def havoc_test_list_unregistered(di: DependencyInjector) -> None:
+async def havoc_test_list_guest(di: DependencyInjector) -> None:
     logger = await di.get(LoggerAdapter)
 
     # Ensure that list does not work for unregistered users
@@ -935,6 +985,7 @@ async def havoc_fluff_upload(di: DependencyInjector) -> None:
     stlfile = open(model, "rb").read()
     logger = await di.get(LoggerAdapter)
 
+    # Simple Upload
     session = await di.get(Session)
     await session.prepare()
     modelid = await do_upload(session, logger, modelname, stlfile, check=True)
@@ -942,6 +993,7 @@ async def havoc_fluff_upload(di: DependencyInjector) -> None:
     await check_in_search(
         session, logger, modelname, [modelname, modelid, stlfile], download=True
     )
+    await session.close()
 
 
 @checker.exploit(0)