Disable hint button if they don't have enough points

.github/workflows/github-actions-demo.yml

@@ -0,0 +1,18 @@
+name: GitHub Actions Demo
+run-name: ${{ github.actor }} is testing out GitHub Actions 🚀
+on: [push]
+jobs:
+  Explore-GitHub-Actions:
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo "🎉 The job was automatically triggered by a ${{ github.event_name }} event."
+      - run: echo "🐧 This job is now running on a ${{ runner.os }} server hosted by GitHub!"
+      - run: echo "🔎 The name of your branch is ${{ github.ref }} and your repository is ${{ github.repository }}."
+      - name: Check out repository code
+        uses: actions/checkout@v3
+      - run: echo "💡 The ${{ github.repository }} repository has been cloned to the runner."
+      - run: echo "🖥️ The workflow is now ready to test your code on the runner."
+      - name: List files in the repository
+        run: |
+          ls ${{ github.workspace }}
+      - run: echo "🍏 This job's status is ${{ job.status }}."

.gitignore

@@ -1 +1,12 @@
-tokens.py
+custom_secrets.py
+byoctf.db
+byoctf.log
+byoctf_diskcache/
+__diskcache__/
+__pycache__/
+.vscode/
+venv
+byoctf.db.after_event
+byoctf.db.after_event_redacted
+byoctf.db.after_event.orig
+settings.py

.python-version

@@ -0,0 +1 @@
+3.11.6

SETUP.md

@@ -0,0 +1,60 @@
+# Setup
+
+Running this software requires a Discord bot. Create one with the following instructions:
+
+- Login to Discord and visit https://discord.com/developers/applications/
+- Click "New Application" and give it a name
+    ![Name your Discord bot](images/discord_name_bot.png)
+- Provide a redirect URL - for our purposes it can be a dummy URL (e.g. `https://google.com`)
+    ![Oauth settings](images/discord_oauth_settings.png)
+- Select appropriate permissions for the default link (optional).
+    ![Bot permissions](images/discord_bot_permissions.png)
+- Select bot permissions again on this page and generate an invite URL
+    ![Generate url](images/discord_gen_bot_url.png)
+- Login to Discord and visit the URL to authorize your bot
+
+After creating your bot, create a channel and a role for your CTF.
+
+- Create a channel to be used for your byoctf event. We will collect its ID later on.
+- Create a byoctf role. Users will obtain this upon registering for the CTF. Again, we will collect its ID later on.
+
+Now you will need to edit a few files and install some dependencies.
+
+- Edit settings.py
+    - Right click in Discord to get these.
+    ```bash
+    "_ctf_guild_id": "" # Target Discord server
+    "_ctf_channel_id": "" # Channel given to users after registration
+    "_ctf_channel_role_id": "" # Role giver to users after registration
+    ```
+- `sudo su`
+- `cd /root`
+- `git clone https://github.com/ShyftXero/byoctf_discord`
+- `cd byoctf_discord`
+- Add Discord bot token - take necessary precautions
+    - `echo "DISCORD_TOKEN='asdfasdfasdf'" > custom_secrets.py`
+- Use rye to install dependencies (https://rye-up.com/guide/)
+    - `sudo su`
+    - `cd  /root/byoctf_discord/`
+    - `python3 -m venv .venv`
+    - `pip install -r requirements.lock`
+- Create `settings.py`
+    - `cp settings_template.py settings.py`
+- Edit `settings.py`
+    ```bash
+    "_ctf_guild_id": 1023627643804975135, # your discord server. user right-click copy ID to get these
+
+    "_ctf_channel_id": 1196678103167139963, # channel ID to give to users once they register.
+
+    "_ctf_channel_role_id": 1196678315092746260, # the ID of the role which will be given to players as they register; makes the channel visible to them.
+    ```
+
+- Create the DB and fill with test data: `python3 ctrl_ctf.py DEV_RESET`
+- Or for no test data: `python3 ctrl_ctf.py INIT`
+- Note: You must repeat the `INIT` command above after making changes to `settings.py`
+- Run it! `python byoctf_discord.py`
+![Alt text](images/byoctf-first-startup.png)
+- Make sure to send your commands via a direct message to the bot. Avoid public channels. Here are some good initial commands to test out and confirm your setup.
+    - `!help`
+    - `!reg TEAM TEAMPASS`
+

bigtest.py

@@ -0,0 +1,167 @@
+import random
+import uuid
+from database import *
+import faker
+import pony
+
+# from mpire import WorkerPool
+
+fake = faker.Faker()
+with db_session:
+    AMOUNT_OF_TEAMS = 25
+    AMOUNT_OF_USERS_PER_TEAM = 4  # Only four players per team
+    AMOUNT_OF_FLAGS = 40
+    AMOUNT_OF_CHALLENGES = 25
+    AMOUNT_OF_HINTS_PER_CHALLENGE = 3
+    AMOUNT_OF_SOLVES = 1000  # this high number will help ensure that there are duplicate attempts from users to submit the same flag or a flag of a teammate or a flag they
+
+    # Define some tag names
+    tag_names = ["byoc", "pentest", "forensics", "reversing", "puzzle", "crypto"]
+    tag_names += [fake.word() for i in range(AMOUNT_OF_CHALLENGES)]
+
+    # Get list of all possible tags
+    try:
+        tags = [upsertTag(name=name) for name in tag_names]
+        ensure_bot_acct()
+        commit()
+    except pony.orm.core.TransactionIntegrityError as e:
+        pass
+
+    # Generate teams
+    print(f"creating {AMOUNT_OF_TEAMS} teams")
+    team_names = set()
+    teams = []
+    for _ in range(AMOUNT_OF_TEAMS):
+        name = fake.company()
+        while name in team_names:
+            name = fake.company()
+        team_names.add(name)
+        t = db.Team(
+            name=name, password=hashlib.sha256(fake.password().encode()).hexdigest()
+        )
+        pub, priv = generate_keys()
+        t.public_key = pub
+        t.private_key = priv
+        teams.append(t)
+
+    # Generate users for each team
+    print(f"creating users")
+    user_names = set()
+    users = []
+    for user in db.User.select():  # get exising db objects
+        users.append(user)
+    for team in teams:
+        for _ in range(AMOUNT_OF_USERS_PER_TEAM):
+            name = fake.user_name()
+            while name in user_names:
+                name = fake.user_name()
+            user_names.add(name)
+            try:
+                u = db.User(name=name, team=team)
+            except BaseException as e:
+                print(e)
+                continue
+            rotate_player_keys(u)
+            users.append(u)
+
+    # Generate flags
+    print(f"creating {AMOUNT_OF_FLAGS} flags")
+    flag_values = set()
+    flags = []
+    for flag in db.Flag.select():  # get exising db objects
+        flags.append(flag)
+    for _ in range(AMOUNT_OF_FLAGS):
+        flag = "FLAG{" + str(uuid.uuid4()) + "}"
+        while flag in flag_values:
+            flag = "FLAG{" + str(uuid.uuid4()) + "}"
+        flag_values.add(flag)
+        flags.append(
+            db.Flag(
+                flag=flag, value=random.randint(50, 1000), author=random.choice(users)
+            )
+        )
+
+    # Generate challenges
+    print(f"creating {AMOUNT_OF_CHALLENGES} challenges")
+    challenges = [
+        db.Challenge(
+            title="_".join(fake.words(nb=random.randint(2, 4))).upper(),
+            description=fake.text(),
+            flags=random.choices(flags, k=random.randint(1, 3)),
+            author=random.choice(users),
+            parent=db.Challenge.select().random(1),
+            children=db.Challenge.select().random(1),
+            byoc=random.choice([True, False]),
+            tags=random.choices(tags, k=random.randint(1, 3)),
+        )
+        for _ in range(AMOUNT_OF_CHALLENGES)
+    ]
+
+    for chall in db.Challenge.select():  # get exising db objects
+        challenges.append(chall)
+
+    # Generate hints for each challenge
+    print(
+        f"creating {AMOUNT_OF_HINTS_PER_CHALLENGE * AMOUNT_OF_CHALLENGES} hints for challenges"
+    )
+    hints = [
+        db.Hint(text=fake.sentence(), cost=random.randint(10, 50), challenge=challenge)
+        for challenge in challenges
+        for _ in range(AMOUNT_OF_HINTS_PER_CHALLENGE)
+    ]
+
+    # Seed funds
+    print("seeding all players 1000 points")
+    seed_funds = [
+        db.Transaction(
+            sender=users[0], recipient=random.choice(users), value=1000, type="seed"
+        )
+        for _ in range(len(users))
+    ]
+
+    # Generate hint buys
+    print(f"creating random hint purchases for users")
+    hint_buys = [
+        buyHint(user=random.choice(users), challenge_id=random.choice(challenges).id)
+        for _ in range(AMOUNT_OF_USERS_PER_TEAM * AMOUNT_OF_TEAMS)
+    ]
+
+    # Generate solves
+    print(f"creating {AMOUNT_OF_SOLVES} solve attempts; valid and invalid")
+    solved_flags = set()
+    for _ in range(AMOUNT_OF_SOLVES):
+        user = random.choice(users)
+        if user.name == "BYOCTF_Automaton#7840":
+            continue
+        chall = random.choice(challenges)
+        if chall.id == 0:
+            continue
+        flags = list(chall.flags)
+        print(chall, flags)
+        flag = random.choice(flags)
+        # while flag.flag in solved_flags:  # Ensure the flag hasn't been solved yet
+        # 	flag = random.choice(flags)
+        solved_flags.add(flag.flag)
+        createSolve(user=user, flag=flag, challenge=chall)
+
+    # Generate random tips
+    print(f"creating {AMOUNT_OF_TEAMS * 4} tips")
+    solved_flags = set()
+    for _ in range(AMOUNT_OF_TEAMS * 4):
+        sender = random.choice(users)
+        recipient = random.choice(users)
+        if "BYOCTF_Automaton#7840" in [sender.name, recipient.name]:
+            continue
+        if sender.id == 0 or recipient.id == 0:
+            continue
+        tip_amount = random.randint(-1, 50) + random.random()
+        print(f"{sender.name} -> {recipient.name} for {tip_amount}")
+        send_tip(sender, recipient, tip_amount=tip_amount)
+
+    # Generate random ratings
+    for _ in range(AMOUNT_OF_SOLVES):
+        rate(
+            random.choice(users),
+            random.choice(challenges),
+            random.randint(-2, 5) + random.random(),
+        )

bot_tests.py

@@ -0,0 +1,32 @@
+import asyncio
+import discord.ext.test as dpytest
+
+from byoctf_discord import bot
+
+
+async def test_view_1():
+    dpytest.configure(bot)
+    await dpytest.message("!v 1")
+    assert (
+        dpytest.verify()
+        .message()
+        .contains()
+        .content("challenge doesn't exist or isn't unlocked yet")
+    )
+
+
+async def test_view_5():
+    dpytest.configure(bot)
+    await dpytest.message("!v 5")
+    assert dpytest.verify().message().contains().content("Title: challenge 5")
+
+
+async def test_whoami():
+    dpytest.configure(bot)
+    await dpytest.message("!whoami")
+    assert dpytest.verify().message().content("Hello World!")
+
+
+asyncio.run(test_view_1())
+asyncio.run(test_view_5())
+asyncio.run(test_whoami())