├── .devcontainer
    └── devcontainer.json
├── .dockerignore
├── .github
    └── workflows
    │   └── test.yml
├── .gitignore
├── Dockerfile
├── LICENSE
├── README.md
├── SECURITY.md
├── ctfd
    ├── Dockerfile
    └── requirements.txt
├── db
    ├── Dockerfile
    └── start.sh
├── docker-compose.yml
├── docs
    ├── architecture.md
    ├── challenge.md
    ├── deployment.md
    ├── development.md
    └── history.md
├── dojo
    ├── dojo
    ├── dojo-init
    ├── dojo-node
    ├── pull_images.sh
    └── warm_cache.sh
├── dojo_plugin
    ├── __init__.py
    ├── api
    │   ├── __init__.py
    │   └── v1
    │   │   ├── belts.py
    │   │   ├── discord.py
    │   │   ├── docker.py
    │   │   ├── dojos.py
    │   │   ├── score.py
    │   │   ├── scoreboard.py
    │   │   ├── search.py
    │   │   ├── ssh_key.py
    │   │   ├── workspace.py
    │   │   └── workspace_tokens.py
    ├── config.py
    ├── models
    │   └── __init__.py
    ├── pages
    │   ├── __init__.py
    │   ├── belts.py
    │   ├── canvas.py
    │   ├── course.py
    │   ├── discord.py
    │   ├── dojo.py
    │   ├── dojos.py
    │   ├── index.py
    │   ├── research.py
    │   ├── sensai.py
    │   ├── settings.py
    │   ├── users.py
    │   ├── workspace.py
    │   └── writeups.py
    ├── scripts
    │   ├── pull_images.py
    │   └── warm_cache.py
    └── utils
    │   ├── __init__.py
    │   ├── awards.py
    │   ├── discord.py
    │   ├── dojo.py
    │   ├── mac_docker.py
    │   ├── scores.py
    │   ├── stats.py
    │   └── workspace.py
├── dojo_theme
    ├── static
    │   ├── css
    │   │   ├── custom.css
    │   │   ├── custom.dev.css
    │   │   └── custom.min.css
    │   ├── font
    │   │   ├── SpaceGrotesk-VariableFont_wght.ttf
    │   │   ├── SpaceMono-Bold.ttf
    │   │   └── SpaceMono-Regular.ttf
    │   ├── img
    │   │   ├── dojo
    │   │   │   ├── discord_logo.svg
    │   │   │   ├── fork.png
    │   │   │   ├── hacker.png
    │   │   │   ├── linkedin_logo.svg
    │   │   │   ├── ninja.png
    │   │   │   ├── student.png
    │   │   │   └── x_logo.svg
    │   │   └── favicon.png
    │   └── js
    │   │   └── dojo
    │   │       ├── activity.dev.js
    │   │       ├── activity.js
    │   │       ├── activity.min.js
    │   │       ├── challenges.dev.js
    │   │       ├── challenges.js
    │   │       ├── challenges.min.js
    │   │       ├── course.dev.js
    │   │       ├── course.js
    │   │       ├── course.min.js
    │   │       ├── grades.dev.js
    │   │       ├── grades.js
    │   │       ├── grades.min.js
    │   │       ├── navbar.dev.js
    │   │       ├── navbar.js
    │   │       ├── navbar.min.js
    │   │       ├── popup.dev.js
    │   │       ├── popup.js
    │   │       ├── popup.min.js
    │   │       ├── scoreboard.dev.js
    │   │       ├── scoreboard.js
    │   │       ├── scoreboard.min.js
    │   │       ├── settings.dev.js
    │   │       ├── settings.js
    │   │       ├── settings.min.js
    │   │       ├── util.dev.js
    │   │       ├── util.js
    │   │       ├── util.min.js
    │   │       ├── writeups.dev.js
    │   │       ├── writeups.js
    │   │       └── writeups.min.js
    └── templates
    │   ├── admin_desktops.html
    │   ├── admin_dojos.html
    │   ├── admin_writeups.html
    │   ├── base.html
    │   ├── belts.html
    │   ├── components
    │       ├── belt.svg
    │       ├── navbar.html
    │       └── stat_dashboard.html
    │   ├── course.html
    │   ├── dojo.html
    │   ├── dojo_activity.html
    │   ├── dojo_admin.html
    │   ├── dojo_admin_user.html
    │   ├── dojo_create.html
    │   ├── dojos.html
    │   ├── grades_admin.html
    │   ├── hacker.html
    │   ├── iframe.html
    │   ├── index.html
    │   ├── macros
    │       ├── scoreboard.html
    │       └── widgets.html
    │   ├── markdown.html
    │   ├── module.html
    │   ├── register.html
    │   ├── research.html
    │   ├── settings.html
    │   ├── workspace.html
    │   └── writeups.html
├── dojofs
    ├── Dockerfile
    └── dojofs
├── etc
    └── systemd
    │   └── system
    │       ├── pwn.college.backup.service
    │       ├── pwn.college.backup.timer
    │       ├── pwn.college.cachewarmer.service
    │       ├── pwn.college.cachewarmer.timer
    │       ├── pwn.college.cloud.backup.service
    │       ├── pwn.college.cloud.backup.timer
    │       ├── pwn.college.imagepuller.service
    │       ├── pwn.college.imagepuller.timer
    │       └── pwn.college.service
├── grafana
    └── datasource.yml
├── homefs
    ├── Dockerfile
    ├── btrfs_volume.py
    ├── homefs.py
    ├── models.py
    ├── utils.py
    ├── volume_driver.py
    └── volume_server.py
├── nginx-proxy
    └── etc
    │   └── nginx
    │       ├── proxy.conf
    │       └── vhost.d
    │           ├── default
    │           └── default_location
├── prometheus
    └── prometheus.yml
├── sshd
    ├── Dockerfile
    ├── auth.py
    ├── enter.py
    ├── mac_docker.py
    ├── sshd_config
    └── start.sh
├── test
    ├── conftest.py
    ├── dojos
    │   ├── fake_blue.yml
    │   ├── fake_green.yml
    │   ├── fake_orange.yml
    │   ├── fake_yellow.yml
    │   ├── forbidden_import.yml
    │   ├── import_override.yml
    │   ├── lfs_dojo.yml
    │   ├── no_import_challenge.yml
    │   ├── no_practice_challenge.yml
    │   ├── no_practice_dojo.yml
    │   ├── progression_locked_dojo.yml
    │   ├── searchable_dojo.yml
    │   ├── simple_award_dojo.yml
    │   ├── surveys_dojo.yml
    │   ├── transfer_dst.yml
    │   └── transfer_src.yml
    ├── local-tester.sh
    ├── test_running.py
    ├── test_welcome.py
    └── utils.py
├── user_firewall.allowed
├── watchdog
    ├── Dockerfile
    ├── docker_prune_images.py
    └── docker_remove_containers.py
├── workspace
    ├── Dockerfile
    ├── additional
    │   ├── additional.nix
    │   ├── bata24-gef.nix
    │   ├── burpsuite.nix
    │   └── ghidra.nix
    ├── core
    │   ├── exec-suid.nix
    │   ├── init.nix
    │   ├── ssh-entrypoint.nix
    │   ├── sudo.nix
    │   └── sudo.py
    ├── flake.nix
    └── services
    │   ├── code.nix
    │   ├── desktop.nix
    │   ├── desktop
    │       ├── etc
    │       │   └── xdg
    │       │   │   └── xfce4
    │       │   │       └── xfconf
    │       │   │           └── xfce-perchannel-xml
    │       │   │               ├── xfce4-desktop.xml
    │       │   │               ├── xfce4-terminal.xml
    │       │   │               ├── xfwm4.xml
    │       │   │               └── xsettings.xml
    │       └── share
    │       │   └── backgrounds
    │       │       └── pwncollege-background.png
    │   ├── service.nix
    │   └── service.py
└── workspacefs
    ├── Dockerfile
    └── workspacefs.c


/.devcontainer/devcontainer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "Development",
 3 |     "build": {
 4 |         "dockerfile": "../Dockerfile",
 5 |         "context": ".."
 6 |     },
 7 |     "workspaceFolder": "/opt/pwn.college",
 8 |     "workspaceMount": "source=${localWorkspaceFolder},target=/opt/pwn.college,type=bind",
 9 |     "runArgs": ["-v", "/tmp/dojo-data-${devcontainerId}:/data"],
10 |     "privileged": true,
11 |     "overrideCommand": false,
12 |     "forwardPorts": [22, 80, 443],
13 |     "portsAttributes": {
14 |         "22": {
15 |             "label": "SSH",
16 |             "onAutoForward": "silent"
17 |         },
18 |         "80": {
19 |             "label": "HTTP",
20 |             "protocol": "http",
21 |             "onAutoForward": "openPreview"
22 |         },
23 |         "443": {
24 |             "label": "HTTPS",
25 |             "onAutoForward": "silent"
26 |         }
27 |     },
28 |     "customizations": {
29 |         "vscode": {
30 |             "extensions": [
31 |                 "ms-python.python",
32 |                 "ms-azuretools.vscode-docker",
33 |                 "ms-vscode-remote.remote-containers"
34 |             ],
35 |             "tasks": [
36 |                 {
37 |                     "label": "Wait for dojo to be ready",
38 |                     "type": "shell",
39 |                     "command": "dojo wait",
40 |                     "runOptions": {
41 |                         "runOn": "folderOpen"
42 |                     }
43 |                 }
44 |             ]
45 |         }
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/.dockerignore:
--------------------------------------------------------------------------------
1 | data/
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.pyc
2 | .DS_Store
3 | opt/
4 | sensai/
5 | data/
6 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | # syntax=docker/dockerfile:1
 2 | 
 3 | FROM ubuntu:24.04
 4 | 
 5 | SHELL ["/bin/bash", "-ceox", "pipefail"]
 6 | 
 7 | ENV DEBIAN_FRONTEND=noninteractive
 8 | ENV LC_CTYPE=C.UTF-8
 9 | 
10 | RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
11 |     --mount=type=cache,target=/var/lib/apt,sharing=locked \
12 |     apt-get update && xargs apt-get install -yqq <<EOF && \
13 |     apt-get clean && rm -rf /var/lib/apt/lists/*
14 |         build-essential
15 |         btrfs-progs
16 |         curl
17 |         git
18 |         host
19 |         htop
20 |         iproute2
21 |         iputils-ping
22 |         jq
23 |         kmod
24 |         unzip
25 |         wget
26 |         wireguard
27 | EOF
28 | 
29 | RUN <<EOF
30 | curl -fsSL https://get.docker.com | /bin/sh
31 | sed -i 's|-H fd:// ||' /lib/systemd/system/docker.service
32 | EOF
33 | 
34 | COPY <<EOF /etc/docker/daemon.json
35 | {
36 |     "data-root": "/data/docker",
37 |     "hosts": ["unix:///run/docker.sock"],
38 |     "builder": {
39 |         "Entitlements": {
40 |             "security-insecure": true
41 |         }
42 |     }
43 | }
44 | EOF
45 | 
46 | ADD https://raw.githubusercontent.com/moby/moby/master/profiles/seccomp/default.json /etc/docker/seccomp.json
47 | 
48 | RUN <<EOF
49 | cd /tmp
50 | wget -O aws.zip "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip"
51 | unzip aws.zip
52 | ./aws/install
53 | rm -rf aws.zip aws
54 | EOF
55 | 
56 | ADD https://github.com/CTFd/CTFd.git#3.6.0 /opt/CTFd
57 | 
58 | COPY <<EOF /etc/fstab
59 | tmpfs /run/dojofs tmpfs defaults,mode=755,shared 0 0
60 | /data/homes /run/homefs none defaults,bind,nosuid 0 0
61 | EOF
62 | 
63 | COPY <<EOF /etc/sysctl.d/90-dojo.conf
64 | fs.inotify.max_user_instances = 8192
65 | fs.inotify.max_user_watches = 1048576
66 | kernel.pty.max = 1048576
67 | kernel.core_pattern = core
68 | kernel.apparmor_restrict_unprivileged_userns = 0
69 | EOF
70 | 
71 | WORKDIR /opt/pwn.college
72 | COPY . .
73 | 
74 | RUN <<EOF
75 | find /opt/pwn.college/etc/systemd/system -type f -exec ln -s {} /etc/systemd/system/ \;
76 | find /opt/pwn.college/etc/systemd/system -type f -name '*.timer' -exec sh -c \
77 |     'ln -s "/etc/systemd/system/$(basename "{}")" "/etc/systemd/system/timers.target.wants/$(basename "{}")"' \;
78 | ln -s /opt/pwn.college/etc/systemd/system/pwn.college.service /etc/systemd/system/multi-user.target.wants/
79 | find /opt/pwn.college/dojo -type f -exec ln -s {} /usr/bin/ \;
80 | EOF
81 | 
82 | EXPOSE 22
83 | EXPOSE 80
84 | EXPOSE 443
85 | CMD ["dojo", "init"]
86 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | BSD 2-Clause License
 2 | 
 3 | Copyright (c) 2022, Arizona Board of Regents
 4 | All rights reserved.
 5 | 
 6 | Redistribution and use in source and binary forms, with or without
 7 | modification, are permitted provided that the following conditions are met:
 8 | 
 9 | 1. Redistributions of source code must retain the above copyright notice, this
10 |    list of conditions and the following disclaimer.
11 | 
12 | 2. Redistributions in binary form must reproduce the above copyright notice,
13 |    this list of conditions and the following disclaimer in the documentation
14 |    and/or other materials provided with the distribution.
15 | 
16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
20 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
23 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # DOJO
 2 | 
 3 | The pwn.college DOJO.
 4 | 
 5 | The best way to understand the DOJO is to experience it.
 6 | Try it out at [pwn.college](https://pwn.college).
 7 | 
 8 | For more information, please check out our [📚 Documentation](./docs):
 9 | - [📜 History](./docs/history.md)
10 | - [🏛️ Architecture](./docs/architecture.md)
11 | - [🚀 Deployment](./docs/deployment.md)
12 | - [🚩 Challenge](./docs/challenge.md)
13 | - [💻 Development](./docs/development.md)
14 | 
15 | Have more questions? Open an [❓ Issue](../../issues) or reach out to us on our [💬 Discord](https://discord.gg/pwncollege).
16 | 
17 | ## Contributing
18 | 
19 | We love Pull Requests! 🌟
20 | Have a small update?
21 | Send a PR so everyone can benefit.
22 | For more substantial changes, open an issue to ensure we're on the same page.
23 | Together, we make this project better for all! ✨
24 | 


--------------------------------------------------------------------------------
/SECURITY.md:
--------------------------------------------------------------------------------
 1 | # Security Policy
 2 | 
 3 | ## Supported Versions
 4 | 
 5 | Only the very latest commit on master is supported.
 6 | 
 7 | ## Reporting a Vulnerability
 8 | 
 9 | Please report vulnerabilities via github's security reporting process: https://github.com/pwncollege/dojo/security
10 | 
11 | ## Emoji Rewards!
12 | 
13 | Significant vulnerabilities in the dojo will be rewarded with a 🐞 emoji award on pwn.college!
14 | 


--------------------------------------------------------------------------------
/ctfd/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM python:3.9-slim-buster AS build
 2 | WORKDIR /opt/CTFd
 3 | 
 4 | RUN apt-get update \
 5 |     && apt-get install -y --no-install-recommends \
 6 |         build-essential \
 7 |         libffi-dev \
 8 |         libssl-dev \
 9 |         git \
10 |     && apt-get clean \
11 |     && rm -rf /var/lib/apt/lists/* \
12 |     && python -m venv /opt/venv
13 | 
14 | ENV PATH="/opt/venv/bin:$PATH"
15 | 
16 | COPY requirements.txt /opt/CTFd/
17 | RUN pip install --no-cache-dir -r requirements.txt
18 | 
19 | # TODO: Remove this when CTFd depends on Flask >= 2.1.0: "safe_join is removed, use werkzeug.utils.safe_join instead"
20 | RUN echo 'from werkzeug.utils import safe_join' >> /opt/venv/lib/python3.9/site-packages/flask/helpers.py
21 | 
22 | COPY . /opt/CTFd
23 | 
24 | FROM python:3.9-slim-buster AS release
25 | WORKDIR /opt/CTFd
26 | 
27 | RUN apt-get update \
28 |     && apt-get install -y --no-install-recommends \
29 |         libffi6 \
30 |         libssl1.1 \
31 |         git \
32 |         openssh-client \
33 |     && apt-get clean \
34 |     && rm -rf /var/lib/apt/lists/*
35 | 
36 | COPY --chown=1001:1001 . /opt/CTFd
37 | 
38 | RUN useradd \
39 |     --no-log-init \
40 |     --shell /bin/bash \
41 |     -u 1001 \
42 |     ctfd \
43 |     && mkdir -p /var/log/CTFd /var/uploads \
44 |     && chown -R 1001:1001 /var/log/CTFd /var/uploads \
45 |     && chmod +x /opt/CTFd/docker-entrypoint.sh
46 | 
47 | COPY --chown=1001:1001 --from=build /opt/venv /opt/venv
48 | ENV PATH="/opt/venv/bin:$PATH"
49 | 
50 | USER 1001
51 | EXPOSE 8000
52 | ENTRYPOINT ["/opt/CTFd/docker-entrypoint.sh"]
53 | 


--------------------------------------------------------------------------------
/ctfd/requirements.txt:
--------------------------------------------------------------------------------
 1 | # DOJO
 2 | docker==6.1.2
 3 | pyyaml==5.4.1
 4 | schema==0.7.5
 5 | bleach==6.1.0
 6 | ipython==8.16.1
 7 | flask-shell-ipython==0.5.1
 8 | 
 9 | # CTFd
10 | Flask==2.2.5
11 | Werkzeug==2.3.8
12 | Flask-SQLAlchemy==2.5.1
13 | Flask-Caching==2.0.2
14 | Flask-Migrate==2.5.3
15 | Flask-Script==2.0.6
16 | SQLAlchemy==1.4.48
17 | SQLAlchemy-Utils==0.41.1
18 | passlib==1.7.4
19 | bcrypt==4.0.1
20 | requests==2.31.0
21 | PyMySQL[rsa]==1.0.2
22 | gunicorn==22.0.0
23 | dataset==1.5.2
24 | cmarkgfm==2022.10.27
25 | redis==4.5.5
26 | gevent==23.9.1
27 | python-dotenv==0.13.0
28 | flask-restx==1.1.0
29 | flask-marshmallow==0.10.1
30 | marshmallow-sqlalchemy==0.17.0
31 | boto3==1.20.0
32 | marshmallow==2.20.2
33 | pydantic==1.10.13
34 | WTForms==2.3.1
35 | python-geoacumen-city==2023.4.15
36 | maxminddb==1.5.4
37 | tenacity==6.2.0
38 | pybluemonday==0.0.12
39 | freezegun==1.2.2
40 | Flask-Babel==2.0.0
41 | 


--------------------------------------------------------------------------------
/db/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM mariadb:10.4.12
2 | 
3 | COPY ./start.sh /start.sh
4 | 


--------------------------------------------------------------------------------
/db/start.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | if [ "${DB_EXTERNAL:-no}" = "no" ]
4 | then
5 |     /docker-entrypoint.sh mysqld --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci --wait_timeout=28800 --log-warnings=0
6 | else
7 |     while true; do sleep 86400; done
8 | fi
9 | 


--------------------------------------------------------------------------------
/docs/development.md:
--------------------------------------------------------------------------------
 1 | # Development
 2 | 
 3 | Before you begin development, please be sure to read the [architecture](./architecture.md) and [deployment](./deployment.md) documentation.
 4 | 
 5 | ## Testing
 6 | 
 7 | You can run the dojo CI testcases locally using `test/local-tester.sh`.
 8 | 
 9 | ## Adding a config entry
10 | 
11 | 1. Add it with a reasonable default in `dojo/dojo-init`
12 | 2. Propagate it to the relevant containers (typically `ctfd`) in `docker-compose.sh`
13 | 3. Load it into a global in `dojo_plugin/config.py`
14 | 4. Import it appropriately
15 | 


--------------------------------------------------------------------------------
/docs/history.md:
--------------------------------------------------------------------------------
 1 | # History
 2 | 
 3 | In the Fall of 2018, tasked with the responsibility of teaching *Computer Systems Security* to a little over a hundred fourth-year undergraduate students at [Arizona State University](https://www.asu.edu), we were faced with a challenge: how do we best teach hundreds of students to become skilled *hackers* in just a single semester?
 4 | With a background in Capture The Flag (CTF) competitions, as members of [Shellphish](https://shellphish.net) and the DEF CON CTF organizing team [Order of the Overflow](https://www.oooverflow.io), we realized our best chance was to teach the course in the same way we learned: by doing.
 5 | And so, the night before the first lecture, at a coffee shop in Tempe, Arizona---late into the night---we bought the domain [pwn.college](https://pwn.college), created the first assignment, and glued together a simple netcat interface in what would become [the first version]((https://github.com/pwncollege/oldschool)) of the pwn.college DOJO.
 6 | 
 7 | For a more academic discussion of pwn.college, see our SIGCSE 2024 papers:
 8 | - [DOJO: Applied Cybersecurity Education In The Browser](https://sefcom.asu.edu/publications/dojo-sigcse24.pdf)
 9 | - [PWN The Learning Curve: Education-First CTF Challenges](https://sefcom.asu.edu/publications/pwn-sigcse24.pdf)
10 | 
11 | See also Connor's PhD work, which focuses on pwn.college:
12 | - [Connor's PhD Dissertation](https://connornelson.com/docs/dissertation-hacking-the-learning-curve.pdf)
13 | - [Connor's PhD Defense - 2024.02.15](https://www.youtube.com/watch?v=qjOBDE_atIk)
14 | - [Connor's PhD Proposal - 2023.11.21](https://www.youtube.com/watch?v=e6JpB2o7QZ0)
15 | 
16 | And some ASU news articles:
17 | - [New ASU institute to create national cybersecurity hub - 2024.06.26](https://news.asu.edu/20240628-science-and-technology-new-asu-institute-create-national-cybersecurity-hub)
18 | - [The next generation of cybersecurity pros drill in the dojo - 2024.03.19](https://news.asu.edu/20240319-science-and-technology-next-generation-cybersecurity-pros-drill-dojo)
19 | - [ASU's cybersecurity dojo - 2021.02.15](https://news.asu.edu/20210215-asu-cybersecurity-dojo-pwn-college-thwart-cyberattacks)
20 | 


--------------------------------------------------------------------------------
/dojo/dojo-node:
--------------------------------------------------------------------------------
  1 | #!/bin/sh
  2 | 
  3 | cd /opt/pwn.college
  4 | 
  5 | if [ -n "$1" ]
  6 | then
  7 |     ACTION="$1"
  8 |     shift
  9 | else
 10 |     ACTION="help"
 11 | fi
 12 | 
 13 | . /data/config.env
 14 | 
 15 | case "$ACTION" in
 16 |     # HELP: refresh: refresh dojo node information
 17 |     "refresh")
 18 |         if [ ! -f /data/wireguard/publickey ]; then
 19 |             mkdir -p /data/wireguard
 20 |             wg genkey | tee /data/wireguard/privatekey | wg pubkey > /data/wireguard/publickey
 21 |         fi
 22 | 
 23 |         touch /data/wireguard/wg0.conf
 24 |         chmod 600 /data/wireguard/wg0.conf
 25 | 
 26 |         private_key=$(cat /data/wireguard/privatekey)
 27 |         node_ip="192.168.42.$((WORKSPACE_NODE + 1))"
 28 | 
 29 |         if [ "${WORKSPACE_NODE}" -eq 0 ]; then
 30 |             printf "%s\n" \
 31 |             "[Interface]" \
 32 |             "PrivateKey = $private_key" \
 33 |             "Address = $node_ip/24" \
 34 |             "ListenPort = 51820" > /data/wireguard/wg0.conf
 35 | 
 36 |             if [ ! -f /data/workspace_nodes.json ]; then
 37 |                 echo '{}' > /data/workspace_nodes.json
 38 |             fi
 39 | 
 40 |             for node in $(jq -r 'keys[]' /data/workspace_nodes.json); do
 41 |                 node_key=$(jq -r '.["'$node'"]' /data/workspace_nodes.json)
 42 |                 node_ip="192.168.42.$((node + 1))"
 43 |                 node_subnet="10.$((node * 16)).0.0/12"
 44 |                 printf "%s\n" \
 45 |                 "" \
 46 |                 "[Peer]" \
 47 |                 "PublicKey = $node_key" \
 48 |                 "AllowedIPs = $node_ip/32, $node_subnet" >> /data/wireguard/wg0.conf
 49 |             done
 50 | 
 51 |         else
 52 |             printf "%s\n" \
 53 |             "[Interface]" \
 54 |             "PrivateKey = $private_key" \
 55 |             "Address = $node_ip/24" \
 56 |             "" \
 57 |             "[Peer]" \
 58 |             "PublicKey = $WORKSPACE_KEY" \
 59 |             "Endpoint = $DOJO_HOST:51820" \
 60 |             "AllowedIPs = 192.168.42.1/32, 10.0.0.0/12" \
 61 |             "PersistentKeepalive = 25" > /data/wireguard/wg0.conf
 62 | 
 63 |             jq '.hosts += ["tcp://'$node_ip':2375"]' /etc/docker/daemon.json > /etc/docker/daemon.json.tmp
 64 |             mv /etc/docker/daemon.json.tmp /etc/docker/daemon.json
 65 |         fi
 66 | 
 67 |         wg-quick down /data/wireguard/wg0.conf || true
 68 |         wg-quick up /data/wireguard/wg0.conf
 69 |         ;;
 70 | 
 71 |     # HELP: show: show dojo node information
 72 |     "show")
 73 |         printf "DOJO_HOST: %s\n" "$DOJO_HOST"
 74 |         printf "WORKSPACE_NODE: %d\n" "$WORKSPACE_NODE"
 75 |         printf "WORKSPACE_KEY: %s\n\n" "${WORKSPACE_KEY:-$(cat /data/wireguard/publickey)}"
 76 |         wg show wg0
 77 |         ;;
 78 | 
 79 |     # HELP: add NODE_ID NODE_KEY: add a node to the dojo
 80 |     "add")
 81 |         if [ "${WORKSPACE_NODE}" -ne 0 ]; then
 82 |             echo "Error: only the main dojo node can add nodes"
 83 |             exit 1
 84 |         fi
 85 |         if [ -n "$1" ] && [ -n "$2" ]; then
 86 |             jq ".[\"$1\"] = \"$2\"" /data/workspace_nodes.json > /data/workspace_nodes.json.tmp
 87 |             mv /data/workspace_nodes.json.tmp /data/workspace_nodes.json
 88 |             dojo-node refresh
 89 |         else
 90 |             echo "Usage: $0 add NODE_ID NODE_KEY"
 91 |         fi
 92 |         ;;
 93 | 
 94 |     # HELP: del NODE_ID: remove a node from the dojo
 95 |     "del")
 96 |         if [ "${WORKSPACE_NODE}" -ne 0 ]; then
 97 |             echo "Error: only the main dojo node can delete nodes"
 98 |             exit 1
 99 |         fi
100 |         if [ -n "$1" ]; then
101 |             jq "del(.\"$1\")" /data/workspace_nodes.json > /data/workspace_nodes.json.tmp
102 |             mv /data/workspace_nodes.json.tmp /data/workspace_nodes.json
103 |             dojo-node refresh
104 |         else
105 |             echo "Usage: $0 del NODE_ID"
106 |         fi
107 |         ;;
108 | 
109 |     # HELP: help: displays this help
110 |     "help")
111 |         echo "Usage: $0 COMMAND [ ARG ]"
112 |         echo
113 |         echo "COMMANDS:"
114 |         echo
115 |         cat "$0" | grep "[H]ELP" | sed -e "s/.*H[E]LP: /\t/"
116 |         ;;
117 | 
118 |     *)
119 |         echo "Unknown command."
120 |         echo ""
121 |         "$0" help
122 |         exit 1
123 |         ;;
124 | esac
125 | 


--------------------------------------------------------------------------------
/dojo/pull_images.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | 
3 | dojo flask /opt/CTFd/CTFd/plugins/dojo_plugin/scripts/pull_images.py
4 | 


--------------------------------------------------------------------------------
/dojo/warm_cache.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | 
3 | dojo flask /opt/CTFd/CTFd/plugins/dojo_plugin/scripts/warm_cache.py
4 | 


--------------------------------------------------------------------------------
/dojo_plugin/api/__init__.py:
--------------------------------------------------------------------------------
 1 | from flask import Blueprint, current_app
 2 | from flask_restx import Api
 3 | 
 4 | from .v1.belts import belts_namespace
 5 | from .v1.discord import discord_namespace
 6 | from .v1.docker import docker_namespace
 7 | from .v1.dojos import dojos_namespace
 8 | from .v1.score import score_namespace
 9 | from .v1.scoreboard import scoreboard_namespace
10 | from .v1.ssh_key import ssh_key_namespace
11 | from .v1.workspace_tokens import workspace_tokens_namespace
12 | from .v1.workspace import workspace_namespace
13 | from .v1.search import search_namespace
14 | 
15 | 
16 | api = Blueprint("pwncollege_api", __name__)
17 | 
18 | api_v1 = Api(api, version="v1", doc=current_app.config.get("SWAGGER_UI"))
19 | api_v1.add_namespace(belts_namespace, "/belts")
20 | api_v1.add_namespace(discord_namespace, "/discord")
21 | api_v1.add_namespace(docker_namespace, "/docker")
22 | api_v1.add_namespace(dojos_namespace, "/dojos")
23 | api_v1.add_namespace(score_namespace, "/score")
24 | api_v1.add_namespace(scoreboard_namespace, "/scoreboard")
25 | api_v1.add_namespace(ssh_key_namespace, "/ssh_key")
26 | api_v1.add_namespace(workspace_tokens_namespace, "/workspace_tokens")
27 | api_v1.add_namespace(workspace_namespace, "/workspace")
28 | api_v1.add_namespace(search_namespace, "/search")
29 | 


--------------------------------------------------------------------------------
/dojo_plugin/api/v1/belts.py:
--------------------------------------------------------------------------------
 1 | from flask_restx import Namespace, Resource
 2 | 
 3 | from ...utils.awards import get_belts
 4 | 
 5 | belts_namespace = Namespace("belts", description="Endpoint to manage belts")
 6 | 
 7 | 
 8 | @belts_namespace.route("")
 9 | class Belts(Resource):
10 |     def get(self):
11 |         return get_belts()
12 | 


--------------------------------------------------------------------------------
/dojo_plugin/api/v1/score.py:
--------------------------------------------------------------------------------
 1 | from flask import request
 2 | from flask_restx import Namespace, Resource
 3 | from CTFd.cache import cache
 4 | from CTFd.models import Users, db, Solves, Challenges
 5 | from CTFd.utils.decorators import ratelimit
 6 | 
 7 | from ...models import Dojos, DojoChallenges
 8 | 
 9 | score_namespace = Namespace("score")
10 | 
11 | @score_namespace.route("/validate")
12 | class ValidateUser(Resource):
13 |     """
14 |     /validate?username=user&email=user@test.com
15 |     This endpoint is publicly available, no auth needed.
16 |     Returns 1 or 0 depending on if username/email exists or not.
17 |     """
18 |     @ratelimit(method="GET", limit=10, interval=60)
19 |     def get(self):
20 |         username = request.args.get("username")
21 |         email = request.args.get("email")
22 |         if not username or not email:
23 |             return {"error": "`username` and `email` parameters are required"}, 400
24 | 
25 |         return int(bool(Users.query.filter_by(name=username, email=email, hidden=False).first()))
26 | 
27 | @score_namespace.route("")
28 | class ScoreUser(Resource):
29 |     """
30 |     /score?username=user
31 |     This endpoint is publicly available with no auth needed.
32 |     Returns formatted data regarding a user's score.
33 |     """
34 |     def get(self):
35 |         username = request.args.get("username")
36 |         if not username:
37 |             return {"error": "`username` parameter is required"}, 400
38 | 
39 |         user = Users.query.filter_by(name=username, hidden=False).first()
40 |         if not user:
41 |             return {"error": "user does not exist"}, 400
42 | 
43 |         official_challenges = (
44 |             Challenges.query
45 |             .join(DojoChallenges)
46 |             .join(Dojos)
47 |             .filter(Dojos.official, DojoChallenges.visible())
48 |             .distinct()
49 |         )
50 |         rank = db.func.row_number().over(
51 |             order_by=(db.func.count(Solves.id).desc(), db.func.max(Solves.id))
52 |         ).label("rank")
53 |         scoreboard = (
54 |             db.session.query(rank, Solves.user_id, db.func.count(Solves.id).label("solves"))
55 |             .join(official_challenges.subquery())
56 |             .group_by(Solves.user_id)
57 |             .order_by(rank)
58 |             .all()
59 |         )
60 | 
61 |         max_score = official_challenges.count()
62 |         user_count = len(scoreboard)
63 |         user_ranking = next((ranking for ranking in scoreboard if ranking.user_id == user.id), None)
64 |         if not user_ranking:
65 |             return {"error": "user is not ranked"}, 400
66 | 
67 |         # rank:score:max_score:challs_solved:chall_count:user_count
68 |         return f"{user_ranking.rank}:{user_ranking.solves}:{max_score}:{user_ranking.solves}:{max_score}:{user_count}"
69 | 


--------------------------------------------------------------------------------
/dojo_plugin/api/v1/search.py:
--------------------------------------------------------------------------------
  1 | from flask import request
  2 | from flask_restx import Namespace, Resource
  3 | from sqlalchemy.orm import joinedload
  4 | from sqlalchemy.sql import or_
  5 | from CTFd.utils.user import get_current_user
  6 | import re
  7 | 
  8 | from ...models import Dojos, DojoModules, DojoChallenges
  9 | 
 10 | search_namespace = Namespace("search", description="Search across dojos, modules, and challenges")
 11 | 
 12 | def highlight_snippet(text, query, context=40):
 13 |     if not text:
 14 |         return None
 15 | 
 16 |     pattern = re.compile(re.escape(query), re.IGNORECASE)
 17 |     match = pattern.search(text)
 18 |     if not match:
 19 |         return None
 20 | 
 21 |     start = max(match.start() - context, 0)
 22 |     end = min(match.end() + context, len(text))
 23 |     snippet = text[start:end]
 24 |     highlighted = pattern.sub(lambda m: f"<b style='font-weight:600; color:#f1c40f'>{m.group(0)}</b>", snippet)
 25 | 
 26 |     if start > 0:
 27 |         highlighted = "…" + highlighted
 28 |     if end < len(text):
 29 |         highlighted += "…"
 30 | 
 31 |     return highlighted
 32 | 
 33 | @search_namespace.route("")
 34 | class Search(Resource):
 35 |     def get(self):
 36 |         query = request.args.get("q", "").strip()
 37 | 
 38 |         user = get_current_user()
 39 | 
 40 |         if not query or len(query) < 2:
 41 |             return {"success": False, "error": "Query too short."}, 400
 42 | 
 43 |         like_query = f"%{query}%"
 44 | 
 45 |         dojos = Dojos.viewable(user=user).filter(
 46 |             or_(Dojos.name.ilike(like_query), Dojos.description.ilike(like_query))
 47 |         )
 48 |         modules = DojoModules.query.join(Dojos.viewable(user=user)).filter(
 49 |             or_(DojoModules.name.ilike(like_query), DojoModules.description.ilike(like_query))
 50 |         )
 51 |         challenges = DojoChallenges.query.join(Dojos.viewable(user=user)).filter(
 52 |             or_(DojoChallenges.name.ilike(like_query), DojoChallenges.description.ilike(like_query))
 53 |         )
 54 | 
 55 |         return {
 56 |             "success": True,
 57 |             "results": {
 58 |                 "dojos": [
 59 |                     {
 60 |                         "id": dojo.reference_id,
 61 |                         "name": dojo.name,
 62 |                         "link": f"/{dojo.reference_id}",
 63 |                         "match": highlight_snippet(dojo.description, query)
 64 |                             if query.lower() in (dojo.description or "").lower()
 65 |                             and query.lower() not in dojo.name.lower()
 66 |                             else None
 67 |                     }
 68 |                     for dojo in dojos
 69 |                 ],
 70 |                 "modules": [
 71 |                     {
 72 |                         "id": module.id,
 73 |                         "name": module.name,
 74 |                         "dojo": {
 75 |                             "id": module.dojo.reference_id,
 76 |                             "name": module.dojo.name,
 77 |                             "link": f"/{module.dojo.reference_id}"
 78 |                         },
 79 |                         "link": f"/{module.dojo.reference_id}/{module.id}",
 80 |                         "match": highlight_snippet(module.description, query)
 81 |                             if query.lower() in (module.description or "").lower()
 82 |                             and query.lower() not in module.name.lower()
 83 |                             else None
 84 |                     }
 85 |                     for module in modules
 86 |                 ],
 87 |                 "challenges": [
 88 |                     {
 89 |                         "id": challenge.id,
 90 |                         "name": challenge.name,
 91 |                         "module": {
 92 |                             "id": challenge.module.id,
 93 |                             "name": challenge.module.name,
 94 |                             "link": f"/{challenge.module.dojo.reference_id}/{challenge.module.id}"
 95 |                         },
 96 |                         "dojo": {
 97 |                             "id": challenge.module.dojo.reference_id,
 98 |                             "name": challenge.module.dojo.name,
 99 |                             "link": f"/{challenge.module.dojo.reference_id}"
100 |                         },
101 |                         "link": f"/{challenge.module.dojo.reference_id}/{challenge.module.id}/{challenge.id}",
102 |                         "match": highlight_snippet(challenge.description, query)
103 |                             if query.lower() in (challenge.description or "").lower()
104 |                             and query.lower() not in challenge.name.lower()
105 |                             else None
106 |                     }
107 |                     for challenge in challenges
108 |                 ]
109 |             }
110 |         }
111 | 


--------------------------------------------------------------------------------
/dojo_plugin/api/v1/ssh_key.py:
--------------------------------------------------------------------------------
 1 | import re
 2 | 
 3 | from flask import request
 4 | from flask_restx import Namespace, Resource
 5 | from sqlalchemy.exc import IntegrityError
 6 | from CTFd.models import db
 7 | from CTFd.utils.decorators import authed_only
 8 | from CTFd.utils.user import get_current_user
 9 | 
10 | from ...models import SSHKeys
11 | 
12 | 
13 | ssh_key_namespace = Namespace(
14 |     "keys", description="Endpoint to manage users' public SSH keys"
15 | )
16 | 
17 | 
18 | @ssh_key_namespace.route("")
19 | class UpdateKey(Resource):
20 |     @authed_only
21 |     def post(self):
22 |         data = request.get_json()
23 |         key_value = data.get("ssh_key", "")
24 | 
25 |         if key_value:
26 |             key_re = "ssh-(rsa|ed25519|dss) AAAA[0-9A-Za-z+/]{1,730}[=]{0,2}"
27 |             key_match = re.match(key_re, key_value)
28 |             if not key_match:
29 |                 return (
30 |                     {
31 |                         "success": False,
32 |                         "error": f"Invalid SSH Key, expected format:<br><code>{key_re}</code>"
33 |                     },
34 |                     400,
35 |                 )
36 |             key_value = key_match.group()
37 | 
38 |         user = get_current_user()
39 | 
40 |         try:
41 |             key = SSHKeys(user_id=user.id, value=key_value)
42 |             db.session.add(key)
43 |             db.session.commit()
44 |         except IntegrityError:
45 |             db.session.rollback()
46 |             return (
47 |                 {"success": False, "error": "SSH Key already in use"},
48 |                 400,
49 |             )
50 | 
51 |         return {"success": True}
52 | 
53 |     @authed_only
54 |     def delete(self):
55 |         data = request.get_json()
56 |         key_value = data.get("ssh_key", "")
57 | 
58 |         user = get_current_user()
59 | 
60 |         key = SSHKeys.query.filter_by(user=user, value=key_value).first()
61 |         if not key:
62 |             return (
63 |                 {"success": False, "error": "SSH Key does not exist"},
64 |                 400,
65 |             )
66 | 
67 |         db.session.delete(key)
68 |         db.session.commit()
69 | 
70 |         return {"success": True}
71 | 


--------------------------------------------------------------------------------
/dojo_plugin/api/v1/workspace.py:
--------------------------------------------------------------------------------
 1 | import hmac
 2 | 
 3 | from flask_restx import Namespace, Resource
 4 | from flask import request, url_for, abort
 5 | from CTFd.models import Users
 6 | from CTFd.utils.user import get_current_user, is_admin
 7 | from CTFd.utils.decorators import authed_only
 8 | 
 9 | from ...utils import get_current_container, container_password
10 | from ...utils.workspace import start_on_demand_service, reset_home
11 | 
12 | 
13 | workspace_namespace = Namespace(
14 |     "workspace", description="Endpoint to manage workspace iframe urls"
15 | )
16 | 
17 | 
18 | @workspace_namespace.route("")
19 | class view_desktop(Resource):
20 |     @authed_only
21 |     def get(self):
22 |         user_id = request.args.get("user")
23 |         password = request.args.get("password")
24 |         service = request.args.get("service")
25 | 
26 |         if not service:
27 |             return {"active": False}
28 | 
29 |         if user_id and not password and not is_admin():
30 |             abort(403)
31 | 
32 |         user = get_current_user() if not user_id else Users.query.filter_by(id=int(user_id)).first_or_404()
33 |         container = get_current_container(user)
34 |         if not container:
35 |             return {"active": False}
36 | 
37 |         if service == "desktop":
38 |             interact_password = container_password(container, "desktop", "interact")
39 |             view_password = container_password(container, "desktop", "view")
40 | 
41 |             if user_id and password:
42 |                 if not hmac.compare_digest(password, interact_password) and not hmac.compare_digest(password, view_password):
43 |                     abort(403)
44 |                 password = password[:8]
45 |             else:
46 |                 password = interact_password[:8]
47 | 
48 |             view_only = user_id is not None
49 |             service_param = "~".join(("desktop", str(user.id), container_password(container, "desktop")))
50 | 
51 |             vnc_params = {
52 |                 "autoconnect": 1,
53 |                 "reconnect": 1,
54 |                 "reconnect_delay": 200,
55 |                 "resize": "remote",
56 |                 "path": url_for("pwncollege_workspace.forward_workspace", service=service_param, service_path="websockify"),
57 |                 "view_only": int(view_only),
58 |                 "password": password,
59 |             }
60 |             iframe_src = url_for("pwncollege_workspace.forward_workspace", service=service_param, service_path="vnc.html", **vnc_params)
61 | 
62 |         elif service == "desktop-windows":
63 |             service_param = "~".join(("desktop-windows", str(user.id), container_password(container, "desktop-windows")))
64 |             vnc_params = {
65 |                 "autoconnect": 1,
66 |                 "reconnect": 1,
67 |                 "reconnect_delay": 200,
68 |                 "resize": "local",
69 |                 "path": url_for("pwncollege_workspace.forward_workspace", service=service_param, service_path="websockify"),
70 |                 "password": "password",
71 |             }
72 |             iframe_src = url_for("pwncollege_workspace.forward_workspace", service=service_param, service_path="vnc.html", **vnc_params)
73 |         else:
74 |             iframe_src = f"/workspace/{service}/"
75 | 
76 |         if start_on_demand_service(user, service) is False:
77 |             return {"active": False}
78 | 
79 |         return {"active": True, "iframe_src": iframe_src, "service": service}
80 | 
81 | 
82 | @workspace_namespace.route("/reset_home")
83 | class ResetHome(Resource):
84 |     @authed_only
85 |     def post(self):
86 |         user = get_current_user()
87 | 
88 |         if not get_current_container(user):
89 |             return {"success": False, "error": "No running container found. Please start a container and try again."}
90 | 
91 |         try:
92 |             reset_home(user.id)
93 |         except AssertionError as e:
94 |             return {"success": False, "error": f"Reset failed with error: {e}"}
95 | 
96 |         return {"success": True, "message": "Home directory reset successfully"}
97 | 


--------------------------------------------------------------------------------
/dojo_plugin/api/v1/workspace_tokens.py:
--------------------------------------------------------------------------------
 1 | from flask import request
 2 | from flask_restx import Namespace, Resource
 3 | from CTFd.models import ma
 4 | from CTFd.utils.decorators import authed_only
 5 | from CTFd.utils.user import get_current_user
 6 | 
 7 | from ...models import WorkspaceTokens
 8 | from ...utils import generate_workspace_token
 9 | 
10 | workspace_tokens_namespace = Namespace(
11 |     "workspace_tokens", description="Endpoint to manage belts"
12 | )
13 | 
14 | 
15 | # https://github.com/CTFd/CTFd/blob/3.6.0/CTFd/schemas/tokens.py#L5
16 | class WorkspaceTokenSchema(ma.ModelSchema):
17 |     class Meta:
18 |         model = WorkspaceTokens
19 |         include_fk = True
20 | 
21 | 
22 | # https://github.com/CTFd/CTFd/blob/3.6.0/CTFd/api/v1/tokens.py#L47
23 | # CTFd implements other
24 | @workspace_tokens_namespace.route("")
25 | class TokenList(Resource):
26 |     @authed_only
27 |     @workspace_tokens_namespace.doc(description="Endpoint to list workspace tokens")
28 |     def get(self):
29 |         user = get_current_user()
30 |         tokens = WorkspaceTokens.query.filter_by(user_id=user.id)
31 |         schema = WorkspaceTokenSchema(only=["id", "expiration"], many=True)
32 |         response = schema.dump(tokens)
33 |         if response.errors:
34 |             return {"success": False, "errors": response.errors}, 400
35 |         return {"success": True, "data": response.data}
36 | 
37 |     @authed_only
38 |     @workspace_tokens_namespace.doc(description="Endpoint to create a token object")
39 |     def post(self):
40 |         req = request.get_json()
41 |         expiration = req.get("expiration")
42 |         if expiration:
43 |             expiration = datetime.datetime.strptime(expiration, "%Y-%m-%d")
44 |         else:
45 |             expiration = None
46 | 
47 |         user = get_current_user()
48 |         token = generate_workspace_token(user, expiration=expiration)
49 |         schema = WorkspaceTokenSchema(only=["id", "expiration", "value"])
50 |         response = schema.dump(token)
51 | 
52 |         if response.errors:
53 |             return {"success": False, "errors": response.errors}, 400
54 |         return {"success": True, "data": response.data}
55 | 


--------------------------------------------------------------------------------
/dojo_plugin/pages/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pwncollege/dojo/601dfe3af5eebbfd0973b79a8c35909e25df492e/dojo_plugin/pages/__init__.py


--------------------------------------------------------------------------------
/dojo_plugin/pages/belts.py:
--------------------------------------------------------------------------------
 1 | from flask import Blueprint, Response, render_template, abort
 2 | 
 3 | from ..utils.awards import get_belts
 4 | 
 5 | 
 6 | belts = Blueprint("pwncollege_belts", __name__)
 7 | 
 8 | 
 9 | @belts.route("/belts")
10 | def view_belts():
11 |     return render_template("belts.html", belt_data=get_belts())
12 | 
13 | 
14 | @belts.route("/belt/<color>.svg")
15 | def view_belt(color):
16 |     colors = {
17 |         "white": ("#f0f0f0", "#8f8f8f", "#ababab", "#000000"),
18 |         "orange": ("#ff7f32", "#994c1e", "#b25923", "#000000"),
19 |         "yellow": ("#ffc627", "#997717", "#b28a1b", "#000000"),
20 |         "green": ("#78be20", "#487213", "#548516", "#000000"),
21 |         "blue": ("#00a3e0", "#0b6384", "#0f739b", "#000000"),
22 |         "black": ("#111111", "#000000", "#080808", "#222222"),
23 |     }
24 |     if color not in colors:
25 |         abort(404)
26 | 
27 |     left, right, center, outline = colors[color]
28 |     svg_content = render_template("components/belt.svg", outline=outline, left=left, right=right, center=center)
29 |     headers = {
30 |         "Cache-Control": "public, max-age=300",
31 |         "Content-Type": "image/svg+xml"
32 |     }
33 |     return Response(svg_content, status=200, headers=headers)
34 | 


--------------------------------------------------------------------------------
/dojo_plugin/pages/discord.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | 
 3 | import requests
 4 | from flask import request, Blueprint, url_for, redirect, abort, current_app
 5 | from sqlalchemy.exc import IntegrityError
 6 | from itsdangerous.url_safe import URLSafeTimedSerializer
 7 | from CTFd.models import db
 8 | from CTFd.utils.user import get_current_user
 9 | from CTFd.utils.decorators import authed_only
10 | 
11 | from ..models import DiscordUsers
12 | from ..config import DISCORD_CLIENT_ID
13 | from ..utils.discord import OAUTH_ENDPOINT, get_discord_id, get_discord_member, add_role
14 | from ..utils.awards import update_awards
15 | 
16 | 
17 | discord = Blueprint("discord", __name__)
18 | discord_oauth_serializer = URLSafeTimedSerializer(current_app.config["SECRET_KEY"], "DISCORD_OAUTH")
19 | 
20 | 
21 | @discord.route("/discord/connect")
22 | @authed_only
23 | def discord_connect():
24 |     if not DISCORD_CLIENT_ID:
25 |         abort(501)
26 | 
27 |     state = discord_oauth_serializer.dumps(get_current_user().id)
28 |     params = dict(client_id=DISCORD_CLIENT_ID,
29 |                   redirect_uri=url_for("discord.discord_redirect", _external=True),
30 |                   response_type="code",
31 |                   scope="identify",
32 |                   state=state)
33 |     oauth_url = requests.Request("GET", f"{OAUTH_ENDPOINT}/authorize", params=params).prepare().url
34 | 
35 |     return redirect(oauth_url)
36 | 
37 | 
38 | @discord.route("/discord/redirect")
39 | @authed_only
40 | def discord_redirect():
41 |     if not DISCORD_CLIENT_ID:
42 |         abort(501)
43 | 
44 |     state = request.args.get("state")
45 |     code = request.args.get("code")
46 | 
47 |     if not state or not code:
48 |         abort(400)
49 | 
50 |     try:
51 |         redirect_user_id = discord_oauth_serializer.loads(state, max_age=300)
52 |         user = get_current_user()
53 |         user_id = user.id
54 |         assert user_id == redirect_user_id, (user_id, redirect_user_id)
55 |         discord_id = get_discord_id(code)
56 |     except Exception as e:
57 |         print(f"ERROR: Discord redirect failed: {e}", file=sys.stderr, flush=True)
58 |         return {"success": False, "error": "Discord redirect failed; OAuth may have taken too long, try again"}, 400
59 | 
60 |     try:
61 |         existing_discord_user = DiscordUsers.query.filter_by(user_id=user_id).first()
62 |         if not existing_discord_user:
63 |             discord_user = DiscordUsers(user_id=user_id, discord_id=discord_id)
64 |             db.session.add(discord_user)
65 |         else:
66 |             existing_discord_user.discord_id = discord_id
67 |         db.session.commit()
68 |         if get_discord_member(discord_id):
69 |             add_role(discord_id, "White Belt")
70 |             update_awards(user)
71 |     except IntegrityError:
72 |         db.session.rollback()
73 |         return {"success": False, "error": "Discord user already in use"}, 400
74 | 
75 |     return redirect("/settings#discord")
76 | 


--------------------------------------------------------------------------------
/dojo_plugin/pages/dojos.py:
--------------------------------------------------------------------------------
 1 | import collections
 2 | 
 3 | from flask import Blueprint, render_template, redirect, url_for
 4 | from CTFd.models import db
 5 | from CTFd.utils.user import get_current_user
 6 | from CTFd.utils.decorators import authed_only, admins_only
 7 | 
 8 | from ..models import DojoChallenges, Dojos, DojoAdmins, DojoMembers
 9 | from ..utils.dojo import generate_ssh_keypair
10 | from ..utils.stats import get_container_stats
11 | 
12 | 
13 | dojos = Blueprint("pwncollege_dojos", __name__)
14 | 
15 | 
16 | @dojos.route("/dojos")
17 | def listing(template="dojos.html"):
18 |     categorized_dojos = {
19 |         "welcome": [],
20 |         "topic": [],
21 |         "public": [],
22 |         "course": [],
23 |         "member": [],
24 |         "admin": [],
25 |     }
26 | 
27 |     user = get_current_user()
28 |     user_dojo_admins = []
29 |     user_dojo_members = []
30 |     dojo_solves = (
31 |         Dojos.viewable(user=user)
32 |         .options(db.undefer(Dojos.modules_count), db.undefer(Dojos.challenges_count))
33 |     )
34 |     if user:
35 |         solves_subquery = (
36 |             DojoChallenges.solves(user=user, ignore_visibility=True, ignore_admins=False)
37 |             .group_by(DojoChallenges.dojo_id)
38 |             .with_entities(DojoChallenges.dojo_id, db.func.count().label("solve_count"))
39 |             .subquery()
40 |         )
41 |         dojo_solves = (
42 |             dojo_solves
43 |             .outerjoin(solves_subquery, Dojos.dojo_id == solves_subquery.c.dojo_id)
44 |             .add_columns(db.func.coalesce(solves_subquery.c.solve_count, 0).label("solve_count"))
45 |         )
46 |         user_dojo_admins = DojoAdmins.query.where(DojoAdmins.user_id == user.id).all()
47 |         user_dojo_members = DojoMembers.query.where(DojoMembers.user_id == user.id).all()
48 |     else:
49 |         dojo_solves = dojo_solves.add_columns(0)
50 | 
51 |     for dojo, solves in dojo_solves:
52 |         if not (dojo.type == "hidden" or (dojo.type == "example" and dojo.official)):
53 |             categorized_dojos.setdefault(dojo.type, []).append((dojo, solves))
54 |             categorized_dojos["member"].extend((dojo_member.dojo, 0) for dojo_member in user_dojo_members
55 |                                                if dojo_member.dojo == dojo and dojo.type not in ["welcome", "topic", "public"])
56 |         categorized_dojos["admin"].extend((dojo_admin.dojo, 0) for dojo_admin in user_dojo_admins if dojo_admin.dojo == dojo)
57 | 
58 |     dojo_container_counts = collections.Counter(stats["dojo"] for stats in get_container_stats())
59 | 
60 |     return render_template(template, user=user, categorized_dojos=categorized_dojos, dojo_container_counts=dojo_container_counts)
61 | 
62 | 
63 | @dojos.route("/dojos/create")
64 | @authed_only
65 | def dojo_create():
66 |     public_key, private_key = generate_ssh_keypair()
67 |     return render_template(
68 |         "dojo_create.html",
69 |         public_key=public_key,
70 |         private_key=private_key,
71 |         example_dojos=Dojos.viewable().where(Dojos.data["type"] == "example").all()
72 |     )
73 | 
74 | 
75 | 
76 | 
77 | @dojos.route("/admin/dojos")
78 | @admins_only
79 | def view_all_dojos():
80 |     return render_template("admin_dojos.html", dojos=Dojos.query.order_by(*Dojos.ordering()).all())
81 | 
82 | 
83 | def dojos_override():
84 |     return redirect(url_for("pwncollege_dojos.listing"), code=301)
85 | 


--------------------------------------------------------------------------------
/dojo_plugin/pages/index.py:
--------------------------------------------------------------------------------
 1 | from flask import url_for, redirect
 2 | from CTFd.views import static_html
 3 | 
 4 | from .dojos import listing
 5 | 
 6 | def static_html_override(route):
 7 |     if route != "index":
 8 |         return static_html(route)
 9 |     else:
10 |         return listing("index.html")
11 | 


--------------------------------------------------------------------------------
/dojo_plugin/pages/research.py:
--------------------------------------------------------------------------------
 1 | from flask import Blueprint, Response, render_template, abort
 2 | 
 3 | from ..utils.awards import get_belts
 4 | 
 5 | 
 6 | research = Blueprint("research", __name__)
 7 | 
 8 | 
 9 | @research.route("/research")
10 | def view_research():
11 |     return render_template("research.html")


--------------------------------------------------------------------------------
/dojo_plugin/pages/sensai.py:
--------------------------------------------------------------------------------
 1 | from urllib.parse import quote
 2 | 
 3 | from flask import request, Blueprint, render_template
 4 | from CTFd.utils.user import get_current_user, is_admin
 5 | from CTFd.utils.decorators import authed_only, admins_only
 6 | from CTFd.plugins import bypass_csrf_protection
 7 | 
 8 | from ..utils import redirect_internal
 9 | from ..utils.dojo import get_current_dojo_challenge
10 | 
11 | 
12 | sensai = Blueprint("pwncollege_sensai", __name__)
13 | 
14 | 
15 | @sensai.route("/sensai")
16 | @authed_only
17 | def view_sensai():
18 |     active = bool(get_current_dojo_challenge())
19 |     return render_template("iframe.html", iframe_name="sensai", iframe_src="/sensai/", active=active)
20 | 
21 | 
22 | @sensai.route("/sensai/", methods=["GET", "POST"])
23 | @sensai.route("/sensai/<path:path>", methods=["GET", "POST"])
24 | @sensai.route("/sensai/", websocket=True)
25 | @sensai.route("/sensai/<path:path>", websocket=True)
26 | @authed_only
27 | @bypass_csrf_protection
28 | def forward_sensai(path=""):
29 |     user = get_current_user()
30 |     path = quote(request.full_path.lstrip("/"), safe="/?=&")
31 |     user_type = "User" if not is_admin() else "Admin"
32 |     return redirect_internal(f"http://sensai/{path}", auth=f"{user_type} {user.id}")
33 | 


--------------------------------------------------------------------------------
/dojo_plugin/pages/settings.py:
--------------------------------------------------------------------------------
 1 | from flask import url_for, render_template
 2 | from CTFd.models import UserTokens
 3 | from CTFd.utils import get_config
 4 | from CTFd.utils.helpers import get_infos, markup
 5 | from CTFd.utils.decorators import authed_only
 6 | from CTFd.utils.user import get_current_user
 7 | 
 8 | from ..models import SSHKeys, DiscordUsers
 9 | from ..config import DISCORD_CLIENT_ID
10 | from ..utils.discord import get_discord_member, discord_avatar_asset
11 | 
12 | 
13 | @authed_only
14 | def settings_override():
15 |     infos = get_infos()
16 | 
17 |     user = get_current_user()
18 |     tokens = UserTokens.query.filter_by(user_id=user.id).all()
19 | 
20 |     ssh_keys = SSHKeys.query.filter_by(user_id=user.id).all()
21 | 
22 |     discord_member = get_discord_member(DiscordUsers.query.filter_by(user=user)
23 |                                         .with_entities(DiscordUsers.discord_id).scalar())
24 | 
25 |     prevent_name_change = get_config("prevent_name_change")
26 | 
27 |     if get_config("verify_emails") and not user.verified:
28 |         confirm_url = markup(url_for("auth.confirm"))
29 |         infos.append(
30 |             markup(
31 |                 "Your email address isn't confirmed!<br>"
32 |                 "Please check your email to confirm your email address.<br><br>"
33 |                 f'To have the confirmation email resent please <a href="{confirm_url}">click here</a>.'
34 |             )
35 |         )
36 | 
37 |     return render_template(
38 |         "settings.html",
39 |         user=user,
40 |         tokens=tokens,
41 |         ssh_keys=[key.value for key in ssh_keys],
42 |         discord_enabled=bool(DISCORD_CLIENT_ID),
43 |         discord_member=discord_member,
44 |         discord_avatar_asset=discord_avatar_asset,
45 |         prevent_name_change=prevent_name_change,
46 |         infos=infos,
47 |     )
48 | 


--------------------------------------------------------------------------------
/dojo_plugin/pages/users.py:
--------------------------------------------------------------------------------
 1 | import datetime
 2 | import hashlib
 3 | import itertools
 4 | import re
 5 | 
 6 | from flask import Blueprint, Response, render_template, abort, url_for
 7 | from sqlalchemy.sql import and_, or_
 8 | from CTFd.utils.user import get_current_user
 9 | from CTFd.utils.decorators import authed_only
10 | from CTFd.models import db, Users, Challenges, Solves
11 | from CTFd.cache import cache
12 | 
13 | from ..models import Dojos, DojoModules, DojoChallenges
14 | from ..utils.scores import dojo_scores, module_scores
15 | from ..utils.awards import get_belts, get_viewable_emojis
16 | 
17 | 
18 | users = Blueprint("pwncollege_users", __name__)
19 | 
20 | 
21 | def view_hacker(user, bypass_hidden=False):
22 |     if user.hidden and not bypass_hidden:
23 |         abort(404)
24 | 
25 |     dojos = (Dojos
26 |              .viewable(user=get_current_user())
27 |              .filter(Dojos.data["type"] != "hidden", Dojos.data["type"] != "course")
28 |              .all())
29 |     user_solves = {}
30 |     for dojo in dojos:
31 |         dojo_id = dojo.id
32 |         user_solves[dojo_id] = {}
33 | 
34 |         for module in dojo.modules:
35 |             module_id = module.id
36 |             solves = module.solves(user=user, ignore_visibility=True, ignore_admins=False) if user else []
37 | 
38 |             if solves:
39 |                 user_solves[dojo_id][module_id] = {
40 |                     solve.challenge_id: solve.date.strftime("%Y-%m-%d %H:%M:%S") for solve in solves
41 |                 }
42 |     return render_template(
43 |         "hacker.html",
44 |         dojos=dojos, user=user,
45 |         dojo_scores=dojo_scores(), module_scores=module_scores(),
46 |         belts=get_belts(), badges=get_viewable_emojis(get_current_user()),
47 |         user_solves=user_solves
48 |     )
49 | 
50 | @users.route("/hacker/<int:user_id>")
51 | def view_other(user_id):
52 |     user = Users.query.filter_by(id=user_id).first()
53 |     if user is None or user.hidden:
54 |         abort(404)
55 |     return view_hacker(user)
56 | 
57 | @users.route("/hacker/<user_name>")
58 | def view_other_name(user_name):
59 |     user = Users.query.filter_by(name=user_name).first()
60 |     if user is None or user.hidden:
61 |         abort(404)
62 |     return view_hacker(user)
63 | 
64 | @users.route("/hacker/")
65 | @authed_only
66 | def view_self():
67 |     return view_hacker(get_current_user(), bypass_hidden=True)
68 | 


--------------------------------------------------------------------------------
/dojo_plugin/pages/workspace.py:
--------------------------------------------------------------------------------
 1 | import hmac
 2 | 
 3 | from flask import request, Blueprint, render_template, url_for, abort
 4 | from CTFd.models import Users
 5 | from CTFd.utils.user import get_current_user, is_admin
 6 | from CTFd.utils.decorators import authed_only
 7 | from CTFd.plugins import bypass_csrf_protection
 8 | 
 9 | from ..models import Dojos
10 | from ..utils import redirect_user_socket, get_current_container, container_password
11 | from ..utils.dojo import get_current_dojo_challenge
12 | from ..utils.workspace import exec_run, start_on_demand_service
13 | 
14 | 
15 | workspace = Blueprint("pwncollege_workspace", __name__)
16 | port_names = {
17 |     "challenge": 80,
18 |     "code": 8080,
19 |     "desktop": 6080,
20 |     "desktop-windows": 6082,
21 | }
22 | 
23 | 
24 | @workspace.route("/workspace/<service>")
25 | @authed_only
26 | def view_workspace(service):
27 |     return render_template("workspace.html", iframe_name="workspace", service=service)
28 | 
29 | @workspace.route("/workspace/<service>/", websocket=True)
30 | @workspace.route("/workspace/<service>/<path:service_path>", websocket=True)
31 | @workspace.route("/workspace/<service>/", methods=["GET", "HEAD", "POST", "PUT", "DELETE", "CONNECT", "OPTIONS", "TRACE", "PATCH"])
32 | @workspace.route("/workspace/<service>/<path:service_path>", methods=["GET", "HEAD", "POST", "PUT", "DELETE", "CONNECT", "OPTIONS", "TRACE", "PATCH"])
33 | @authed_only
34 | @bypass_csrf_protection
35 | def forward_workspace(service, service_path=""):
36 |     prefix = f"/workspace/{service}/"
37 |     assert request.full_path.startswith(prefix)
38 |     service_path = request.full_path[len(prefix):]
39 | 
40 |     if service.count("~") == 0:
41 |         service_name = service
42 |         try:
43 |             user = get_current_user()
44 |             port = int(port_names.get(service_name, service_name))
45 |         except ValueError:
46 |             abort(404)
47 | 
48 |     elif service.count("~") == 1:
49 |         service_name, user_id = service.split("~", 1)
50 |         try:
51 |             user = Users.query.filter_by(id=int(user_id)).first_or_404()
52 |             port = int(port_names.get(service_name, service_name))
53 |         except ValueError:
54 |             abort(404)
55 | 
56 |         container = get_current_container(user)
57 |         if not container:
58 |             abort(404)
59 |         dojo = Dojos.from_id(container.labels["dojo.dojo_id"]).first()
60 |         if not dojo.is_admin():
61 |             abort(403)
62 | 
63 |     elif service.count("~") == 2:
64 |         service_name, user_id, access_code = service.split("~", 2)
65 |         try:
66 |             user = Users.query.filter_by(id=int(user_id)).first_or_404()
67 |             port = int(port_names.get(service_name, service_name))
68 |         except ValueError:
69 |             abort(404)
70 | 
71 |         container = get_current_container(user)
72 |         if not container:
73 |             abort(404)
74 |         correct_access_code = container_password(container, service_name)
75 |         if not hmac.compare_digest(access_code, correct_access_code):
76 |             abort(403)
77 | 
78 |     else:
79 |         abort(404)
80 | 
81 |     current_user = get_current_user()
82 |     if user != current_user:
83 |         print(f"User {current_user.id} is accessing User {user.id}'s workspace (port {port})", flush=True)
84 | 
85 |     return redirect_user_socket(user, port, service_path)
86 | 


--------------------------------------------------------------------------------
/dojo_plugin/pages/writeups.py:
--------------------------------------------------------------------------------
  1 | import datetime
  2 | import pytz
  3 | 
  4 | from flask import request, Blueprint, render_template, abort, send_file
  5 | from flask.helpers import safe_join
  6 | from CTFd.models import db, Users, Files, Comments
  7 | from CTFd.utils.user import get_current_user, is_admin
  8 | from CTFd.utils.decorators import authed_only, admins_only
  9 | from CTFd.utils.uploads import get_uploader
 10 | 
 11 | 
 12 | writeups = Blueprint("writeups", __name__)
 13 | 
 14 | 
 15 | class WriteupFiles(Files):
 16 |     __mapper_args__ = {"polymorphic_identity": "writeup"}
 17 |     user_id = db.Column(db.Integer, db.ForeignKey("users.id", ondelete="CASCADE"))
 18 |     date = db.Column(db.DateTime, default=datetime.datetime.utcnow)
 19 | 
 20 | 
 21 | class WriteupComments(Comments):
 22 |     __mapper_args__ = {"polymorphic_identity": "writeup"}
 23 |     writeup_id = db.Column(db.Integer, db.ForeignKey("files.id", ondelete="CASCADE"))
 24 |     accepted = db.Column(db.Boolean)
 25 | 
 26 | 
 27 | def writeup_weeks():
 28 |     date = datetime.datetime.fromisoformat
 29 |     return [
 30 |         (date("2022-09-11T23:59:59-07:00"), date("2022-09-13T23:59:59-07:00")),
 31 |     ]
 32 | 
 33 | 
 34 | def all_writeups(user_id=None):
 35 |     writeups = WriteupFiles.query
 36 |     if user_id:
 37 |         writeups = writeups.filter_by(user_id=user_id)
 38 |     writeups = writeups.order_by(WriteupFiles.date)
 39 | 
 40 |     weeks = writeup_weeks()
 41 | 
 42 |     for writeup in writeups:
 43 |         writeup_date = pytz.UTC.localize(writeup.date)
 44 |         for start, end in weeks:
 45 |             if start < writeup_date < end:
 46 |                 yield (start, end), writeup
 47 | 
 48 | 
 49 | @writeups.route("/writeups", methods=["GET", "POST"])
 50 | @authed_only
 51 | def view_writeups():
 52 |     user = get_current_user()
 53 | 
 54 |     weeks = {week: (None, None) for week in writeup_weeks()}
 55 | 
 56 |     if request.method == "POST":
 57 |         writeup_file = request.files.get("writeup")
 58 |         if writeup_file:
 59 |             uploader = get_uploader()
 60 |             location = uploader.upload(
 61 |                 file_obj=writeup_file, filename=writeup_file.filename
 62 |             )
 63 |             writeup = WriteupFiles(type="writeup", location=location, user_id=user.id)
 64 |             db.session.add(writeup)
 65 |             db.session.commit()
 66 | 
 67 |     for week, writeup in all_writeups(user.id):
 68 |         comment = (
 69 |             WriteupComments.query.filter_by(writeup_id=writeup.id)
 70 |             .order_by(WriteupComments.date.desc())
 71 |             .first()
 72 |         )
 73 |         weeks[week] = (writeup, comment)
 74 | 
 75 |     countdown = None
 76 |     now = pytz.UTC.localize(datetime.datetime.utcnow())
 77 |     for i, (start, end) in enumerate(weeks):
 78 |         if start < now < end:
 79 |             remainder = datetime.timedelta(seconds=int((end - now).total_seconds()))
 80 |             countdown = f"Writeup #{i + 1} due in {remainder}"
 81 |             break
 82 | 
 83 |     return render_template("writeups.html", weeks=weeks, countdown=countdown)
 84 | 
 85 | 
 86 | @writeups.route("/writeups/<int:writeup_id>")
 87 | @authed_only
 88 | def view_writeup(writeup_id):
 89 |     user = get_current_user()
 90 |     writeup = WriteupFiles.query.filter_by(id=writeup_id).first()
 91 |     if not writeup:
 92 |         abort(404)
 93 |     if user.id != writeup.user_id and not is_admin():
 94 |         abort(404)
 95 |     uploader = get_uploader()
 96 |     return send_file(safe_join(uploader.base_path, writeup.location))
 97 | 
 98 | 
 99 | @writeups.route("/admin/writeups", methods=["GET", "POST"])
100 | @admins_only
101 | def view_admin_writeups():
102 |     weeks = {week: {} for week in writeup_weeks()}
103 | 
104 |     if request.method == "POST":
105 |         user = get_current_user()
106 | 
107 |         writeup_id = int(request.form["writeup_id"])
108 |         content = request.form["comment"]
109 |         accepted = request.form["accepted"].lower() == "accept"
110 | 
111 |         comment = WriteupComments(
112 |             type="writeup",
113 |             content=content,
114 |             author_id=user.id,
115 |             writeup_id=writeup_id,
116 |             accepted=accepted,
117 |         )
118 |         db.session.add(comment)
119 |         db.session.commit()
120 | 
121 |     for week, writeup in all_writeups():
122 |         user = Users.query.filter_by(id=writeup.user_id).first()
123 |         comment = (
124 |             WriteupComments.query.filter_by(writeup_id=writeup.id)
125 |             .order_by(WriteupComments.date.desc())
126 |             .first()
127 |         )
128 |         weeks[week][user] = (writeup, comment)
129 | 
130 |     return render_template("admin_writeups.html", weeks=weeks)
131 | 


--------------------------------------------------------------------------------
/dojo_plugin/scripts/pull_images.py:
--------------------------------------------------------------------------------
 1 | import logging
 2 | 
 3 | import docker
 4 | 
 5 | from ..utils import all_docker_clients
 6 | from ..config import DOCKER_USERNAME, DOCKER_TOKEN
 7 | 
 8 | 
 9 | logger = logging.getLogger(__name__)
10 | logger.setLevel(logging.INFO)
11 | 
12 | 
13 | for image, in DojoChallenges.query.with_entities(db.distinct(DojoChallenges.data["image"])).all():
14 |     if not image or image.startswith("mac:") or image.startswith("pwncollege-"):
15 |         continue
16 | 
17 |     for client in all_docker_clients():
18 |         if DOCKER_USERNAME and DOCKER_TOKEN:
19 |             client.login(DOCKER_USERNAME, DOCKER_TOKEN)
20 |         logger.info(f"Pulling image {image} on {client.api.base_url}...")
21 |         try:
22 |             client.images.pull(image)
23 |         except docker.errors.ImageNotFound:
24 |             logger.error(f"... image not found: {image} on {client.api.base_url}...")
25 |         except Exception as e:
26 |             logger.error(f"... error: {image} on {client.api.base_url}...", exc_info=e)
27 | 


--------------------------------------------------------------------------------
/dojo_plugin/scripts/warm_cache.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import logging
 3 | 
 4 | os.environ["CACHE_WARMER"] = "1"
 5 | 
 6 | logger = logging.getLogger(__name__)
 7 | logger.setLevel(logging.INFO)
 8 | 
 9 | from ..utils import scores
10 | scores.dojo_scores()
11 | logger.info("Dojo scores cache warmed.")
12 | scores.module_scores()
13 | logger.info("Module scores cache warmed.")
14 | 
15 | from ..utils import stats
16 | stats.get_container_stats()
17 | logger.info("Container stats cache warmed.")
18 | for dojo in Dojos.query:
19 | 	stats.get_dojo_stats(dojo)
20 | 	logger.info(f"Dojo stats cache warmed for {dojo.reference_id}.")
21 | 


--------------------------------------------------------------------------------
/dojo_plugin/utils/discord.py:
--------------------------------------------------------------------------------
  1 | import time
  2 | 
  3 | import requests
  4 | from flask import url_for
  5 | from CTFd.cache import cache
  6 | 
  7 | from ..models import DiscordUsers
  8 | from ..config import DISCORD_CLIENT_ID, DISCORD_CLIENT_SECRET, DISCORD_BOT_TOKEN, DISCORD_GUILD_ID
  9 | 
 10 | 
 11 | OAUTH_ENDPOINT = "https://discord.com/api/oauth2"
 12 | API_ENDPOINT = "https://discord.com/api/v9"
 13 | 
 14 | 
 15 | def discord_request(endpoint, method="GET", **kwargs):
 16 |     headers = {"Authorization": f"Bot {DISCORD_BOT_TOKEN}"}
 17 |     while True:
 18 |         response = requests.request(method, f"{API_ENDPOINT}{endpoint}", headers=headers, **kwargs)
 19 |         if response.status_code == 429:
 20 |             retry_after = response.json().get("retry_after", 1)
 21 |             time.sleep(retry_after)
 22 |             continue
 23 |         break
 24 |     response.raise_for_status()
 25 |     if "application/json" in response.headers.get("Content-Type", ""):
 26 |         return response.json()
 27 |     else:
 28 |         return response.content
 29 | 
 30 | 
 31 | def guild_request(endpoint, method="GET", **kwargs):
 32 |     return discord_request(f"/guilds/{DISCORD_GUILD_ID}{endpoint}", method=method, **kwargs)
 33 | 
 34 | 
 35 | def get_bot_join_server_url():
 36 |     # "Server Members Intent" also required
 37 |     params = dict(client_id=DISCORD_CLIENT_ID, scope="bot", permissions=268437504, guild_id=DISCORD_GUILD_ID)
 38 |     url = requests.Request("GET", f"{OAUTH_ENDPOINT}/authorize", params=params).prepare().url
 39 |     return url
 40 | 
 41 | 
 42 | def discord_avatar_asset(discord_member):
 43 |     if not discord_member:
 44 |         return url_for("views.themes", path="img/dojo/discord_logo.svg")
 45 |     discord_id = discord_member["user"]["id"]
 46 |     discord_avatar = discord_member["user"]["avatar"]
 47 |     return f"https://cdn.discordapp.com/avatars/{discord_id}/{discord_avatar}.png"
 48 | 
 49 | 
 50 | def get_discord_id(auth_code):
 51 |     data = {
 52 |         "client_id": DISCORD_CLIENT_ID,
 53 |         "client_secret": DISCORD_CLIENT_SECRET,
 54 |         "grant_type": "authorization_code",
 55 |         "code": auth_code,
 56 |         "redirect_uri": url_for("discord.discord_redirect", _external=True),
 57 |     }
 58 |     headers = {
 59 |         "Content-Type": "application/x-www-form-urlencoded",
 60 |     }
 61 |     response = requests.post(f"{OAUTH_ENDPOINT}/token", data=data, headers=headers)
 62 |     access_token = response.json()["access_token"]
 63 | 
 64 |     headers = {
 65 |         "Authorization": f"Bearer {access_token}",
 66 |     }
 67 |     response = requests.get(f"{API_ENDPOINT}/users/@me", headers=headers)
 68 |     discord_id = response.json()["id"]
 69 |     return discord_id
 70 | 
 71 | 
 72 | @cache.memoize(timeout=3600)
 73 | def get_discord_member(discord_id):
 74 |     if not DISCORD_BOT_TOKEN or not discord_id:
 75 |         return
 76 |     try:
 77 |         result = guild_request(f"/members/{discord_id}")
 78 |     except requests.exceptions.RequestException:
 79 |         return
 80 |     if result.get("message") == "Unknown Member":
 81 |         return None
 82 |     return result
 83 | 
 84 | 
 85 | @cache.memoize(timeout=3600)
 86 | def get_discord_roles():
 87 |     if not DISCORD_BOT_TOKEN:
 88 |         return {}
 89 |     roles = guild_request("/roles")
 90 |     return {role["name"]: role["id"] for role in roles}
 91 | 
 92 | 
 93 | def send_message(message, channel_name):
 94 |     channel_ids = [channel["id"] for channel in guild_request("/channels") if channel["name"] == channel_name]
 95 |     assert len(channel_ids) == 1
 96 |     channel_id = channel_ids[0]
 97 |     json = dict(content=message)
 98 |     discord_request(f"/channels/{channel_id}/messages", method="POST", json=json)
 99 | 
100 | 
101 | def add_role(discord_id, role_name):
102 |     role_id = get_discord_roles()[role_name]
103 |     guild_request(f"/members/{discord_id}/roles/{role_id}", method="PUT")
104 | 


--------------------------------------------------------------------------------
/dojo_plugin/utils/scores.py:
--------------------------------------------------------------------------------
 1 | from sqlalchemy.sql import or_
 2 | from CTFd.models import Solves, db
 3 | from CTFd.cache import cache
 4 | from ..models import Dojos, DojoChallenges
 5 | from . import force_cache_updates
 6 | 
 7 | def scores_query(granularity, dojo_filter):
 8 |     solve_count = db.func.count(Solves.id).label("solve_count")
 9 |     last_solve_date = db.func.max(Solves.date).label("last_solve_date")
10 |     fields = granularity + [ Solves.user_id, solve_count, last_solve_date ]
11 |     grouping = granularity + [ Solves.user_id ]
12 | 
13 |     dsc_query = db.session.query(*fields).where(
14 |         Dojos.dojo_id == DojoChallenges.dojo_id, DojoChallenges.challenge_id == Solves.challenge_id,
15 |         dojo_filter
16 |     ).group_by(*grouping).order_by(Dojos.id, solve_count.desc(), last_solve_date)
17 | 
18 |     return dsc_query
19 | 
20 | @cache.memoize(timeout=1200, forced_update=force_cache_updates)
21 | def dojo_scores():
22 |     dsc_query = scores_query([Dojos.id], or_(Dojos.data["type"] == "public", Dojos.official))
23 | 
24 |     user_ranks = { }
25 |     user_solves = { }
26 |     dojo_ranks = { }
27 |     for dojo_id, user_id, solve_count, _ in dsc_query:
28 |         dojo_ranks.setdefault(dojo_id, [ ]).append(user_id)
29 |         user_ranks.setdefault(user_id, {})[dojo_id] = len(dojo_ranks[dojo_id])
30 |         user_solves.setdefault(user_id, {})[dojo_id] = solve_count
31 | 
32 |     return {
33 |         "user_ranks": user_ranks,
34 |         "user_solves": user_solves,
35 |         "dojo_ranks": dojo_ranks
36 |     }
37 | 
38 | @cache.memoize(timeout=1200, forced_update=force_cache_updates)
39 | def module_scores():
40 |     dsc_query = scores_query([Dojos.id, DojoChallenges.module_index], or_(Dojos.data["type"] == "public", Dojos.official))
41 | 
42 |     user_ranks = { }
43 |     user_solves = { }
44 |     module_ranks = { }
45 |     for dojo_id, module_idx, user_id, solve_count, _ in dsc_query:
46 |         module_ranks.setdefault(dojo_id, {}).setdefault(module_idx, []).append(user_id)
47 |         user_ranks.setdefault(user_id, {}).setdefault(dojo_id, {})[module_idx] = len(module_ranks[dojo_id][module_idx])
48 |         user_solves.setdefault(user_id, {}).setdefault(dojo_id, {})[module_idx] = solve_count
49 | 
50 |     return {
51 |         "user_ranks": user_ranks,
52 |         "user_solves": user_solves,
53 |         "module_ranks": module_ranks
54 |     }
55 | 


--------------------------------------------------------------------------------
/dojo_plugin/utils/stats.py:
--------------------------------------------------------------------------------
  1 | from CTFd.cache import cache
  2 | from CTFd.models import Solves
  3 | from datetime import datetime, timedelta
  4 | from sqlalchemy import func, desc
  5 | 
  6 | from . import force_cache_updates, get_all_containers, DojoChallenges
  7 | 
  8 | @cache.memoize(timeout=1200, forced_update=force_cache_updates)
  9 | def get_container_stats():
 10 |     containers = get_all_containers()
 11 |     return [{attr: container.labels[f"dojo.{attr}_id"]
 12 |             for attr in ["dojo", "module", "challenge"]}
 13 |             for container in containers]
 14 | 
 15 | @cache.memoize(timeout=1200, forced_update=force_cache_updates)
 16 | def get_dojo_stats(dojo):
 17 |     now = datetime.now()
 18 |     solves_query = dojo.solves()
 19 | 
 20 |     total_challenges = len(dojo.challenges)
 21 |     visible_challenges = len([c for c in dojo.challenges if c.visible()])
 22 | 
 23 |     total_stats = solves_query.with_entities(
 24 |         func.count(Solves.id).label('total_solves'),
 25 |         func.count(func.distinct(Solves.user_id)).label('total_users')
 26 |     ).first()
 27 | 
 28 |     total_solves = total_stats.total_solves or 0
 29 |     total_users = total_stats.total_users or 0
 30 | 
 31 |     # chart data
 32 |     snapshot_days = [1, 7, 30, 60]
 33 |     chart_labels = ['Today', '1w ago', '1mo ago', '2mo ago']
 34 |     chart_solves = []
 35 |     chart_users = []
 36 | 
 37 |     for days_ago in snapshot_days:
 38 |         # get day given how many days ago
 39 |         snapshot_date = now - timedelta(days=days_ago)
 40 |         day_start = snapshot_date.replace(hour=0, minute=0, second=0, microsecond=0)
 41 |         day_end = day_start + timedelta(days=1)
 42 | 
 43 |         # get day info
 44 |         day_stats = solves_query.filter(
 45 |             Solves.date >= day_start,
 46 |             Solves.date < day_end
 47 |         ).with_entities(
 48 |             func.count(Solves.id).label('day_solves'),
 49 |             func.count(func.distinct(Solves.user_id)).label('day_users')
 50 |         ).first()
 51 | 
 52 |         chart_solves.append(day_stats.day_solves or 0)
 53 |         chart_users.append(day_stats.day_users or 0)
 54 | 
 55 |     # recent solves data
 56 |     basic_query = (
 57 |         solves_query
 58 |         .with_entities(
 59 |             Solves.date.label('date'),
 60 |             DojoChallenges.name.label('challenge_name')
 61 |         )
 62 |         .filter(Solves.date >= now - timedelta(days=7))
 63 |         .order_by(desc(Solves.date))
 64 |         .limit(5)
 65 |         .all()
 66 |     )
 67 | 
 68 |     recent_solves = [
 69 |         {
 70 |             'challenge_name': f'{solve.challenge_name}',
 71 |             'date': solve.date,
 72 |             'date_display': solve.date.strftime('%m/%d/%y %I:%M %p') if solve.date else 'Unknown time'
 73 |         }
 74 |         for solve in basic_query
 75 |     ]
 76 | 
 77 |     def trend_calc(current, previous):
 78 |         if previous == 0:
 79 |             return 100 if current > 0 else 0
 80 |         change = ((current - previous) / previous) * 100
 81 |         return max(-99, min(999, round(change)))
 82 | 
 83 |     trends = {
 84 |         'solves': trend_calc(chart_solves[0], chart_solves[1]),
 85 |         'users': trend_calc(chart_users[0], chart_users[1]),
 86 |         'active': 0,
 87 |         'challenges': 0,
 88 |     }
 89 | 
 90 |     return {
 91 |         'users': total_users,
 92 |         'challenges': total_challenges,
 93 |         'visible_challenges': visible_challenges,
 94 |         'solves': total_solves,
 95 |         'recent_solves': recent_solves,
 96 |         'trends': trends,
 97 |         'chart_data': {
 98 |             'labels': chart_labels,
 99 |             'solves': chart_solves,
100 |             'users': chart_users
101 |         }
102 |     }
103 | 


--------------------------------------------------------------------------------
/dojo_plugin/utils/workspace.py:
--------------------------------------------------------------------------------
 1 | import docker
 2 | from CTFd.models import Users
 3 | 
 4 | from . import user_docker_client
 5 | 
 6 | on_demand_services = { "code", "desktop"}
 7 | 
 8 | def start_on_demand_service(user, service_name):
 9 |     if service_name not in on_demand_services:
10 |         return
11 |     try:
12 |         exec_run(
13 |             f"/run/current-system/sw/bin/dojo-{service_name}",
14 |             workspace_user="hacker",
15 |             user_id=user.id,
16 |             assert_success=True,
17 |         )
18 |     except docker.errors.NotFound:
19 |         return False
20 |     return True
21 | 
22 | 
23 | def exec_run(cmd, *, shell=False, assert_success=True, workspace_user="root", user_id=None, container=None, **kwargs):
24 |     # TODO: Cleanup this interface
25 |     if workspace_user == "root":
26 |         workspace_user = "0"
27 |     if workspace_user == "hacker":
28 |         workspace_user = "1000"
29 | 
30 |     if shell:
31 |         cmd = f"""/bin/sh -c \"
32 |         {cmd}
33 |         \""""
34 | 
35 |     if not container:
36 |         docker_client = user_docker_client(Users.query.get(user_id))
37 |         container = docker_client.containers.get(f"user_{user_id}")
38 |     exit_code, output = container.exec_run(cmd, user=workspace_user, **kwargs)
39 |     if assert_success:
40 |         assert exit_code in (0, None), output
41 |     return exit_code, output
42 | 
43 | def reset_home(user_id):
44 |     exec_run(f"/bin/tar cvzf /tmp/home-backup.tar.gz /home/hacker", user_id=user_id, shell=True, workspace_user="hacker")
45 |     exec_run(f"find /home/hacker -mindepth 1 -delete", user_id=user_id, shell=True, workspace_user="root")
46 |     exec_run(f"chown hacker:hacker /home/hacker", user_id=user_id, shell=True, workspace_user="root")
47 |     exec_run(f"cp /tmp/home-backup.tar.gz /home/hacker/", user_id=user_id, shell=True, workspace_user="hacker")


--------------------------------------------------------------------------------
/dojo_theme/static/css/custom.dev.css:
--------------------------------------------------------------------------------
1 | custom.css


--------------------------------------------------------------------------------
/dojo_theme/static/css/custom.min.css:
--------------------------------------------------------------------------------
1 | custom.css


--------------------------------------------------------------------------------
/dojo_theme/static/font/SpaceGrotesk-VariableFont_wght.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pwncollege/dojo/601dfe3af5eebbfd0973b79a8c35909e25df492e/dojo_theme/static/font/SpaceGrotesk-VariableFont_wght.ttf


--------------------------------------------------------------------------------
/dojo_theme/static/font/SpaceMono-Bold.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pwncollege/dojo/601dfe3af5eebbfd0973b79a8c35909e25df492e/dojo_theme/static/font/SpaceMono-Bold.ttf


--------------------------------------------------------------------------------
/dojo_theme/static/font/SpaceMono-Regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pwncollege/dojo/601dfe3af5eebbfd0973b79a8c35909e25df492e/dojo_theme/static/font/SpaceMono-Regular.ttf


--------------------------------------------------------------------------------
/dojo_theme/static/img/dojo/discord_logo.svg:
--------------------------------------------------------------------------------
 1 | <svg width="71" height="55" viewBox="0 0 71 55" fill="none" xmlns="http://www.w3.org/2000/svg">
 2 | <g clip-path="url(#clip0)">
 3 | <path d="M60.1045 4.8978C55.5792 2.8214 50.7265 1.2916 45.6527 0.41542C45.5603 0.39851 45.468 0.440769 45.4204 0.525289C44.7963 1.6353 44.105 3.0834 43.6209 4.2216C38.1637 3.4046 32.7345 3.4046 27.3892 4.2216C26.905 3.0581 26.1886 1.6353 25.5617 0.525289C25.5141 0.443589 25.4218 0.40133 25.3294 0.41542C20.2584 1.2888 15.4057 2.8186 10.8776 4.8978C10.8384 4.9147 10.8048 4.9429 10.7825 4.9795C1.57795 18.7309 -0.943561 32.1443 0.293408 45.3914C0.299005 45.4562 0.335386 45.5182 0.385761 45.5576C6.45866 50.0174 12.3413 52.7249 18.1147 54.5195C18.2071 54.5477 18.305 54.5139 18.3638 54.4378C19.7295 52.5728 20.9469 50.6063 21.9907 48.5383C22.0523 48.4172 21.9935 48.2735 21.8676 48.2256C19.9366 47.4931 18.0979 46.6 16.3292 45.5858C16.1893 45.5041 16.1781 45.304 16.3068 45.2082C16.679 44.9293 17.0513 44.6391 17.4067 44.3461C17.471 44.2926 17.5606 44.2813 17.6362 44.3151C29.2558 49.6202 41.8354 49.6202 53.3179 44.3151C53.3935 44.2785 53.4831 44.2898 53.5502 44.3433C53.9057 44.6363 54.2779 44.9293 54.6529 45.2082C54.7816 45.304 54.7732 45.5041 54.6333 45.5858C52.8646 46.6197 51.0259 47.4931 49.0921 48.2228C48.9662 48.2707 48.9102 48.4172 48.9718 48.5383C50.038 50.6034 51.2554 52.5699 52.5959 54.435C52.6519 54.5139 52.7526 54.5477 52.845 54.5195C58.6464 52.7249 64.529 50.0174 70.6019 45.5576C70.6551 45.5182 70.6887 45.459 70.6943 45.3942C72.1747 30.0791 68.2147 16.7757 60.1968 4.9823C60.1772 4.9429 60.1437 4.9147 60.1045 4.8978ZM23.7259 37.3253C20.2276 37.3253 17.3451 34.1136 17.3451 30.1693C17.3451 26.225 20.1717 23.0133 23.7259 23.0133C27.308 23.0133 30.1626 26.2532 30.1066 30.1693C30.1066 34.1136 27.28 37.3253 23.7259 37.3253ZM47.3178 37.3253C43.8196 37.3253 40.9371 34.1136 40.9371 30.1693C40.9371 26.225 43.7636 23.0133 47.3178 23.0133C50.9 23.0133 53.7545 26.2532 53.6986 30.1693C53.6986 34.1136 50.9 37.3253 47.3178 37.3253Z" fill="#5865F2"/>
 4 | </g>
 5 | <defs>
 6 | <clipPath id="clip0">
 7 | <rect width="71" height="55" fill="white"/>
 8 | </clipPath>
 9 | </defs>
10 | </svg>
11 | 


--------------------------------------------------------------------------------
/dojo_theme/static/img/dojo/fork.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pwncollege/dojo/601dfe3af5eebbfd0973b79a8c35909e25df492e/dojo_theme/static/img/dojo/fork.png


--------------------------------------------------------------------------------
/dojo_theme/static/img/dojo/hacker.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pwncollege/dojo/601dfe3af5eebbfd0973b79a8c35909e25df492e/dojo_theme/static/img/dojo/hacker.png


--------------------------------------------------------------------------------
/dojo_theme/static/img/dojo/linkedin_logo.svg:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
2 | <svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
3 | <path d="M18.72 3.99997H5.37C5.19793 3.99191 5.02595 4.01786 4.86392 4.07635C4.70189 4.13484 4.55299 4.22471 4.42573 4.34081C4.29848 4.45692 4.19537 4.59699 4.12232 4.75299C4.04927 4.909 4.0077 5.07788 4 5.24997V18.63C4.01008 18.9901 4.15766 19.3328 4.41243 19.5875C4.6672 19.8423 5.00984 19.9899 5.37 20H18.72C19.0701 19.9844 19.4002 19.8322 19.6395 19.5761C19.8788 19.32 20.0082 18.9804 20 18.63V5.24997C20.0029 5.08247 19.9715 4.91616 19.9078 4.76122C19.8441 4.60629 19.7494 4.466 19.6295 4.34895C19.5097 4.23191 19.3672 4.14059 19.2108 4.08058C19.0544 4.02057 18.8874 3.99314 18.72 3.99997ZM9 17.34H6.67V10.21H9V17.34ZM7.89 9.12997C7.72741 9.13564 7.5654 9.10762 7.41416 9.04768C7.26291 8.98774 7.12569 8.89717 7.01113 8.78166C6.89656 8.66615 6.80711 8.5282 6.74841 8.37647C6.6897 8.22474 6.66301 8.06251 6.67 7.89997C6.66281 7.73567 6.69004 7.57169 6.74995 7.41854C6.80986 7.26538 6.90112 7.12644 7.01787 7.01063C7.13463 6.89481 7.2743 6.80468 7.42793 6.74602C7.58157 6.68735 7.74577 6.66145 7.91 6.66997C8.07259 6.66431 8.2346 6.69232 8.38584 6.75226C8.53709 6.8122 8.67431 6.90277 8.78887 7.01828C8.90344 7.13379 8.99289 7.27174 9.05159 7.42347C9.1103 7.5752 9.13699 7.73743 9.13 7.89997C9.13719 8.06427 9.10996 8.22825 9.05005 8.3814C8.99014 8.53456 8.89888 8.6735 8.78213 8.78931C8.66537 8.90513 8.5257 8.99526 8.37207 9.05392C8.21843 9.11259 8.05423 9.13849 7.89 9.12997ZM17.34 17.34H15V13.44C15 12.51 14.67 11.87 13.84 11.87C13.5822 11.8722 13.3313 11.9541 13.1219 12.1045C12.9124 12.2549 12.7546 12.4664 12.67 12.71C12.605 12.8926 12.5778 13.0865 12.59 13.28V17.34H10.29V10.21H12.59V11.21C12.7945 10.8343 13.0988 10.5225 13.4694 10.3089C13.84 10.0954 14.2624 9.98848 14.69 9.99997C16.2 9.99997 17.34 11 17.34 13.13V17.34Z" fill="#000000"/>
4 | </svg>


--------------------------------------------------------------------------------
/dojo_theme/static/img/dojo/ninja.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pwncollege/dojo/601dfe3af5eebbfd0973b79a8c35909e25df492e/dojo_theme/static/img/dojo/ninja.png


--------------------------------------------------------------------------------
/dojo_theme/static/img/dojo/student.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pwncollege/dojo/601dfe3af5eebbfd0973b79a8c35909e25df492e/dojo_theme/static/img/dojo/student.png


--------------------------------------------------------------------------------
/dojo_theme/static/img/dojo/x_logo.svg:
--------------------------------------------------------------------------------
1 | <svg width="1200" height="1227" viewBox="0 0 1200 1227" fill="none" xmlns="http://www.w3.org/2000/svg">
2 | <path d="M714.163 519.284L1160.89 0H1055.03L667.137 450.887L357.328 0H0L468.492 681.821L0 1226.37H105.866L515.491 750.218L842.672 1226.37H1200L714.137 519.284H714.163ZM569.165 687.828L521.697 619.934L144.011 79.6944H306.615L611.412 515.685L658.88 583.579L1055.08 1150.3H892.476L569.165 687.854V687.828Z" fill="white"/>
3 | </svg>
4 | 


--------------------------------------------------------------------------------
/dojo_theme/static/img/favicon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pwncollege/dojo/601dfe3af5eebbfd0973b79a8c35909e25df492e/dojo_theme/static/img/favicon.png


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/activity.dev.js:
--------------------------------------------------------------------------------
1 | activity.js


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/activity.min.js:
--------------------------------------------------------------------------------
1 | activity.js


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/challenges.dev.js:
--------------------------------------------------------------------------------
1 | challenges.js


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/challenges.min.js:
--------------------------------------------------------------------------------
1 | challenges.js


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/course.dev.js:
--------------------------------------------------------------------------------
1 | course.js


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/course.js:
--------------------------------------------------------------------------------
 1 | var error_template =
 2 |     '<div class="alert alert-danger alert-dismissable" role="alert">\n' +
 3 |     '  <span class="sr-only">Error:</span>\n' +
 4 |     '  <span id="message"></span>' +
 5 |     '  <button type="button" class="close" data-dismiss="alert" aria-label="Close"><span aria-hidden="true">×</span></button>\n' +
 6 |     '</div>';
 7 | 
 8 | var warning_template =
 9 |     '<div class="alert alert-warning alert-dismissable" role="alert">\n' +
10 |     '  <span class="sr-only">Warning:</span>\n' +
11 |     '  <span id="message"></span>' +
12 |     '  <button type="button" class="close" data-dismiss="alert" aria-label="Close"><span aria-hidden="true">×</span></button>\n' +
13 |     '</div>';
14 | 
15 | var success_template =
16 |     '<div class="alert alert-success alert-dismissable submit-row" role="alert">\n' +
17 |     '  <strong>Success!</strong>\n' +
18 |     '  <span id="message"></span>' +
19 |     '  <button type="button" class="close" data-dismiss="alert" aria-label="Close"><span aria-hidden="true">×</span></button>\n' +
20 |     '</div>';
21 | 
22 | function form_fetch_and_show(name, endpoint, method, success_message) {
23 |     const form = $(`#${name}-form`);
24 |     const results = $(`#${name}-results`);
25 |     form.submit(e => {
26 |         e.preventDefault();
27 |         results.empty();
28 |         const params = form.serializeJSON();
29 | 
30 |         CTFd.fetch(endpoint, {
31 |             method: method,
32 |             credentials: "same-origin",
33 |             headers: {
34 |                 Accept: "application/json",
35 |                 "Content-Type": "application/json"
36 |             },
37 |             body: JSON.stringify(params)
38 |         }).then(response => {
39 |             return response.json()
40 |         }).then(result => {
41 |             if (!result.success) {
42 |                 results.html(error_template);
43 |                 results.find("#message").html(result.error);
44 |             } else if (result.warning) {
45 |                 results.html(warning_template);
46 |                 results.find("#message").html(result.warning);
47 |             } else {
48 |                 results.html(success_template);
49 |                 results.find("#message").text(success_message);
50 |             }
51 |         });
52 |     });
53 | }
54 | 
55 | $(() => {
56 |     form_fetch_and_show("identity", `/dojo/${init.dojo}/course/identity`, "PATCH", "Your identity has been updated");
57 | 
58 |     let navLinks = document.querySelectorAll('.nav-link');
59 |     navLinks.forEach(link => {
60 |         link.addEventListener('click', function(e) {
61 |             let pathSegments = window.location.pathname.split('/');
62 |             let clickedSegment = this.id.split('-')[1];
63 |             let courseIndexFromEnd = [...pathSegments].reverse().findIndex(seg => seg === 'course');
64 |             let coursePosition = pathSegments.length - courseIndexFromEnd - 1;
65 |             let newUrl = [...pathSegments.slice(0, coursePosition + 1), clickedSegment].join('/');
66 |             history.pushState({}, '', newUrl);
67 |         });
68 |     });
69 | 
70 |     let pathSegments = window.location.pathname.split('/');
71 |     let lastSegment = pathSegments[pathSegments.length - 1];
72 |     let secondLastSegment = pathSegments[pathSegments.length - 2];
73 | 
74 |     if (lastSegment === 'course') return;
75 | 
76 |     if (secondLastSegment === 'course' && lastSegment) {
77 |         let targetTab = document.querySelector(`#${lastSegment}`);
78 |         let targetNav = document.querySelector(`#course-${lastSegment}-tab`);
79 | 
80 |         if (targetTab) {
81 |             let activeTabs = document.querySelectorAll('.tab-pane.active');
82 |             activeTabs.forEach(tab => {
83 |                 tab.classList.remove('active');
84 |             });
85 |             targetTab.classList.add('active');
86 |             targetTab.classList.add('show');
87 | 
88 |             let activeNavs = document.querySelectorAll('.nav-link.active');
89 |             activeNavs.forEach(nav => {
90 |                 nav.classList.remove('active');
91 |             });
92 |             targetNav.classList.add('active');
93 |         }
94 |     }
95 | });


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/course.min.js:
--------------------------------------------------------------------------------
1 | course.js


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/grades.dev.js:
--------------------------------------------------------------------------------
1 | grades.js


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/grades.min.js:
--------------------------------------------------------------------------------
1 | grades.js


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/navbar.dev.js:
--------------------------------------------------------------------------------
1 | navbar.js


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/navbar.min.js:
--------------------------------------------------------------------------------
1 | navbar.js


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/popup.dev.js:
--------------------------------------------------------------------------------
1 | popup.js


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/popup.js:
--------------------------------------------------------------------------------
 1 | document.addEventListener("DOMContentLoaded", function () {
 2 |     if (!init?.userId) return;
 3 | 
 4 |     checkUserAwards()
 5 |         .then(handleAwardPopup)
 6 |         .catch(error => console.error("Award check failed:", error));
 7 | });
 8 | 
 9 | function checkUserAwards() {
10 |     const endpoint = `/api/v1/users/${init.userId}/awards`;
11 |     return CTFd.fetch(endpoint, {
12 |         method: "GET",
13 |         credentials: "same-origin",
14 |         headers: {"Accept": "application/json"}
15 |     }).then(response => response.json());
16 | }
17 | 
18 | function handleAwardPopup(response) {
19 |     if (!response?.success || !response.data?.length) return;
20 | 
21 |     const award = response.data.sort((a, b) => new Date(a.date) - new Date(b.date)).pop();
22 | 
23 |     const lastAwardDate = new Date(award.date);
24 |     const twoDaysAgo = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000);
25 |     const lastPopup = new Date(localStorage.getItem("lastPopup"));
26 | 
27 |     if (lastAwardDate <= twoDaysAgo || lastAwardDate <= lastPopup) return;
28 | 
29 |     localStorage.setItem("lastPopup", lastAwardDate.toISOString());
30 | 
31 |     showAwardPopup(award);
32 | }
33 | 
34 | function showAwardPopup(award) {
35 |     const isBelt = Array.from(award.name).length > 1;
36 | 
37 |     const image = isBelt
38 |         ? `<img src="/belt/${award.name}.svg" class="belt-image">`
39 |         : `<div class="emoji-display">${award.name}</div>`;
40 | 
41 |     const message = isBelt
42 |         ? `You have officially been awarded your ${award.name} belt!`
43 |         : `You have officially been awarded the ${award.name} badge!`;
44 | 
45 |     const popupContent = {
46 |         header: "Congratulations!",
47 |         body: message,
48 |         image: image,
49 |         logos: {
50 |             ninja: `${CTFd.config.urlRoot}/themes/dojo_theme/static/img/dojo/ninja.png`,
51 |             linkedin: `${CTFd.config.urlRoot}/themes/dojo_theme/static/img/dojo/linkedin_logo.svg`,
52 |             x: `${CTFd.config.urlRoot}/themes/dojo_theme/static/img/dojo/x_logo.svg`
53 |         },
54 |         profileUrl: `${window.location.protocol}//${window.location.host}/hacker/${init.userId}`
55 |     };
56 | 
57 |     const popup = document.createElement("div");
58 |     popup.className = "popup-overlay";
59 |     popup.innerHTML = `
60 |         <div class="popup-content">
61 |             <button id="closePopup">&times;</button>
62 |             ${popupContent.image}
63 |             <h1>${popupContent.header}</h1>
64 |             <p>${popupContent.body}</p>
65 |             <img src="${popupContent.logos.ninja}" class="logo-image">
66 |             <div class="social-share">
67 |                 <a href="https://linkedin.com/share?url=${popupContent.profileUrl}"
68 |                     class="share-button"
69 |                     target="_blank"
70 |                     aria-label="Post on LinkedIn">
71 |                     <img src="${popupContent.logos.linkedin}">
72 |                     <span title="Post on LinkedIn"></span>Post
73 |                 </a>
74 |                 <a href="https://twitter.com/intent/tweet?url=${popupContent.profileUrl}"
75 |                     class="share-button"
76 |                     target="_blank"
77 |                     aria-label="Post on X">
78 |                     <img src="${popupContent.logos.x}">
79 |                     <span title="Post on X"></span>Post
80 |                 </a>
81 |             </div>
82 |         </div>
83 |     `;
84 | 
85 |     document.body.appendChild(popup);
86 |     popup.querySelector("#closePopup").addEventListener("click", () => {
87 |         popup.remove();
88 |     });
89 | 
90 |     popup.addEventListener("click", (e) => {
91 |         if (e.target === popup){
92 |             popup.remove();
93 |         }
94 |     });
95 | }
96 | 


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/popup.min.js:
--------------------------------------------------------------------------------
1 | popup.js


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/scoreboard.dev.js:
--------------------------------------------------------------------------------
1 | scoreboard.js


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/scoreboard.js:
--------------------------------------------------------------------------------
  1 | function loadScoreboard(duration, page) {
  2 |     const dojo = init.dojo;
  3 |     const module = init.module || "_";
  4 |     const scoreboard = $("#scoreboard");
  5 | 
  6 |     const endpoint = `/pwncollege_api/v1/scoreboard/${dojo}/${module}/${duration}/${page}`;
  7 |     scoreboard.empty();
  8 |     message = "Loading."
  9 |     scoreboard.html(`<td colspan=6>${message}</td>`);
 10 |     setTimeout(function loadmsg() {
 11 |         if (scoreboard.html().includes(message)) {
 12 |             message += "."
 13 |             scoreboard.html(`<td colspan=6>${message}</td>`);
 14 |             setTimeout(loadmsg, 1000);
 15 |         }
 16 |     }, 500);
 17 |     $("#scoreboard-control-week").removeClass("scoreboard-page-selected");
 18 |     $("#scoreboard-control-month").removeClass("scoreboard-page-selected");
 19 |     $("#scoreboard-control-all").removeClass("scoreboard-page-selected");
 20 |     if (duration == 7) {
 21 |         $("#scoreboard-control-week").addClass("scoreboard-page-selected");
 22 |         $("#scoreboard-heading").text("7-Day Scoreboard:");
 23 |     }
 24 |     if (duration == 30) {
 25 |         $("#scoreboard-control-month").addClass("scoreboard-page-selected");
 26 |         $("#scoreboard-heading").text("30-Day Scoreboard:");
 27 |     }
 28 |     if (duration == 0) {
 29 |         $("#scoreboard-control-all").addClass("scoreboard-page-selected");
 30 |         $("#scoreboard-heading").text("All-Time Scoreboard:");
 31 |     }
 32 | 
 33 |     CTFd.fetch(endpoint, {
 34 |         method: "GET",
 35 |         credentials: "same-origin",
 36 |         headers: {
 37 |             Accept: "application/json",
 38 |             "Content-Type": "application/json"
 39 |         },
 40 |     }).then(response => {
 41 |         return response.json()
 42 |     }).then(result => {
 43 |         scoreboard.empty();
 44 | 
 45 |         const standings = result.standings;
 46 |         if (result.me) {
 47 |             if (result.me.rank < standings[0].rank)
 48 |                 standings.splice(0, 0, result.me)
 49 |             else if (result.me.rank > standings[standings.length - 1].rank)
 50 |                 standings.splice(standings.length, 0, result.me)
 51 |         }
 52 |         standings.forEach(user => {
 53 |             const row = $(`
 54 |             <tr>
 55 |               <td scope="row" class="col-md-1"><b>#${user.rank}</b></td>
 56 |               <td class="col-md-1 p-0">
 57 |                 <img src="${user.symbol}" class="scoreboard-symbol">
 58 |               </td>
 59 |               <td class="col-md-4">
 60 |                 <a href="${user.url}" class="scoreboard-name brand-mono">
 61 |                 </a>
 62 |               </td>
 63 |               <td class="scoreboard-completions col-md-4">
 64 |               </td>
 65 |               <td class="col-md-1">
 66 |                 <img src="${user.belt}" class="scoreboard-belt">
 67 |               </td>
 68 |               <td class="col-md-1"><b>${user.solves}</b></td>
 69 |             </tr>
 70 |             `);
 71 |             row.find(".scoreboard-name").text(user.name.slice(0, 50));
 72 | 
 73 |             user.badges.forEach(badge => {
 74 |                 if (!badge.url) badge.url = "#";
 75 |                 var count = badge.count <= 1 ? "" : `<sub>x${badge.count}</sub>`
 76 |                 row.find(".scoreboard-completions").append($(`
 77 |                     <span title="${badge.text}">
 78 |                     <a href="${badge.url}">${badge.emoji}</a>${count}
 79 |                     </span><span> </span>
 80 |                 `));
 81 |             })
 82 | 
 83 |             if (result.me && user.user_id == result.me.user_id)
 84 |                 row.addClass("scoreboard-row-me");
 85 |             scoreboard.append(row);
 86 |         });
 87 | 
 88 |         const scoreboardPages = $("#scoreboard-pages");
 89 |         scoreboardPages.empty();//A
 90 |         if (result.pages.length > 1) {
 91 |             result.pages.forEach(i => {
 92 |                 const pageButton = $(`
 93 |                 <li class="scoreboard-page"><a href="javascript:loadScoreboard('${duration}', ${i})">${i}</a></li>
 94 |                 `);
 95 |                 pageButton.addClass(i == page ? "scoreboard-page-selected" : "scoreboard-page-unselected");
 96 |                 scoreboardPages.append(pageButton);
 97 |             });
 98 |         }
 99 |     });
100 | }
101 | 


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/scoreboard.min.js:
--------------------------------------------------------------------------------
1 | scoreboard.js


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/settings.dev.js:
--------------------------------------------------------------------------------
1 | settings.js


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/settings.min.js:
--------------------------------------------------------------------------------
1 | settings.js


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/util.dev.js:
--------------------------------------------------------------------------------
1 | util.js


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/util.js:
--------------------------------------------------------------------------------
 1 | function copyToClipboard(event) {
 2 |     event.preventDefault();
 3 |     const text = event.currentTarget.dataset.copy;
 4 |     navigator.clipboard.writeText(text)
 5 |     .then(() => {
 6 |         const tooltip = event.currentTarget.querySelector("#tooltip");
 7 |         const original = tooltip.innerText;
 8 |         tooltip.innerText = "Copied!";
 9 |         setTimeout(() => {
10 |             tooltip.innerText = original;
11 |         }, 1000);
12 |     })
13 | }
14 | 
15 | document.addEventListener("DOMContentLoaded", function () {
16 |     if (new Date() >= new Date("2025-03-01")) return;
17 | 
18 |     const urlParams = new URLSearchParams(window.location.search);
19 |     const theme = urlParams.get("theme");
20 | 
21 |     if (theme) {
22 |         document.body.classList.add(`theme-${theme}`);
23 |         localStorage.setItem('theme', theme);
24 |     } else {
25 |         const storedTheme = localStorage.getItem('theme');
26 |         document.body.classList.add(`theme-${storedTheme}`);
27 |     }
28 | });


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/util.min.js:
--------------------------------------------------------------------------------
1 | util.js


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/writeups.dev.js:
--------------------------------------------------------------------------------
1 | writeups.js


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/writeups.js:
--------------------------------------------------------------------------------
 1 | $(() => {
 2 |     $('a[data-toggle="pill"]').on("show.bs.tab", function (event) {
 3 |         console.log(event.currentTarget);
 4 |         const target = $($(event.currentTarget).attr("href"));
 5 |         target.find("embed").each(function (i, embed) {
 6 |             if ($(embed).prop("src"))
 7 |                 return;
 8 |             $(embed).prop("src", function () {
 9 |                 return $(this).data("src");
10 |             });
11 |         });
12 |     });
13 | });
14 | 


--------------------------------------------------------------------------------
/dojo_theme/static/js/dojo/writeups.min.js:
--------------------------------------------------------------------------------
1 | writeups.js


--------------------------------------------------------------------------------
/dojo_theme/templates/admin_desktops.html:
--------------------------------------------------------------------------------
 1 | {% extends "admin/base.html" %}
 2 | 
 3 | {% block content %}
 4 | <div class="jumbotron">
 5 |   <div class="container">
 6 |     <h1>Joinable User Desktops Sessions</h1>
 7 |   </div>
 8 | </div>
 9 | <div class="container">
10 |   <div id="desktops" class="row">
11 |     <div class="col-md-12">
12 |       <table class="table table-striped">
13 |         <thead>
14 |           <tr>
15 |             <td scope="col"><b>Desktop Sessions</b></td>
16 |           </tr>
17 |         </thead>
18 |         <tbody>
19 |           {% for user in users %}
20 |           <tr>
21 |             <td><a href="/desktop/{{ user.id }}">{{ user.name }}</a></td>
22 |           </tr>
23 |           {% endfor %}
24 |         </tbody>
25 |       </table>
26 |     </div>
27 |   </div>
28 | </div>
29 | {% endblock %}
30 | 
31 | {% block scripts %}
32 | {% endblock %}
33 | 


--------------------------------------------------------------------------------
/dojo_theme/templates/admin_dojos.html:
--------------------------------------------------------------------------------
 1 | {% extends "admin/base.html" %}
 2 | 
 3 | {% block content %}
 4 | <div class="jumbotron">
 5 |   <div class="container">
 6 |     <h1>All Dojos</h1>
 7 |   </div>
 8 | </div>
 9 | <div class="container">
10 |     {% for dojo in dojos %}
11 |     <h2><a href="{{ url_for('pwncollege_dojo.view_dojo', dojo=dojo.reference_id) }}">{{ dojo.name }}</a></h2>
12 |     <b>Reference ID: </b><code>{{ dojo.reference_id }}</code>
13 |     <br>
14 |     <b>Dojo ID: </b><code>{{ dojo.hex_dojo_id }}</code>
15 |     <br>
16 |     <b>Git Hash: </b><code>{{ dojo.hash[:8] }}</code>
17 |     <br>
18 |     <b>Last Commit: </b><code>{{ dojo.last_commit_time }}</code>
19 |     <br>
20 |     <b>Admins</b>
21 |     <ul>
22 |         {% for admin in dojo.admins %}
23 |         <li>{{ admin.user.name }}</li>
24 |         {% endfor %}
25 |     </ul>
26 |     <hr>
27 |     {% endfor %}
28 | </div>
29 | {% endblock %}
30 | 
31 | 


--------------------------------------------------------------------------------
/dojo_theme/templates/admin_writeups.html:
--------------------------------------------------------------------------------
 1 | {% extends "admin/base.html" %}
 2 | 
 3 | {% block stylesheets %}
 4 | <style>
 5 |   .embed-responsive-a {
 6 |       padding-top: 141.42%;
 7 |   }
 8 | </style>
 9 | {% endblock %}
10 | 
11 | {% block content %}
12 | <div class="jumbotron">
13 |   <div class="container">
14 |     <h1>Writeups</h1>
15 |   </div>
16 | </div>
17 | <div class="container">
18 |   <div class="row">
19 |     <div class="col-md-2 offset-md-1">
20 |       <div class="nav flex-column nav-pills" role="tablist">
21 |         {% for week in weeks %}
22 |         {% set active = "active" if loop.first  else "" %}
23 | 	<a class="nav-link {{ active }}" id="writeups-week{{ loop.index }}-tab" data-toggle="pill" href="#writeups-week{{ loop.index }}" role="tab">Writeup #{{ loop.index }}</a>
24 |         {% endfor %}
25 |       </div>
26 |     </div>
27 |     <div class="col-md-8">
28 |       <div class="tab-content" id="v-pills-tabContent">
29 |         {% for week, users in weeks.items() %}
30 |         {% set week_index = loop.index %}
31 |         {% set active = "show active" if loop.first  else "" %}
32 | 	<div class="tab-pane fade {{ active }}" id="writeups-week{{ week_index }}" role="tabpanel">
33 |           <h2>Writeup #{{ loop.index }}</h2>
34 |           <br>
35 |           <div class="accordion" id="writeups-week{{ week_index }}-accordion">
36 |             {% for user, (writeup, comment) in users.items() %}
37 |             {% set content = comment.content if comment else "" %}
38 |             <div class="card">
39 |               <div class="card-header" id="writeupsHeading-week{{ week_index }}-user{{ user.id }}">
40 |                 <h2 class="mb-0">
41 |                   <button class="btn btn-link text-decoration-none collapsed w-100" type="button" data-toggle="collapse" data-target="#writeups-week{{ week_index }}-user{{ user.id }}" aria-expanded="false" aria-controls="writeups-week{{ week_index }}-user{{ user.id }}">
42 |                     <h4 class="text-left">{{ user.name | truncate(50) }}</h4>
43 |                   </button>
44 |                 </h2>
45 |               </div>
46 |               <div id="writeups-week{{ week_index }}-user{{ user.id }}" class="collapse" aria-labelledby="writeupsHeading-week{{ week_index }}-user{{ user.id }}" data-parent="#writeups-week{{ week_index }}-accordion">
47 |                 <div class="card-body">
48 |                   {% if comment %}
49 |                   <h3>{{ "Accepted" if comment.accepted else "Rejected" }}</h3>
50 |                   {% endif %}
51 |                   <div class="embed-responsive embed-responsive-a">
52 |                     <embed {{ "data-src" if week_index != 1 else "src" }}="/writeups/{{ writeup.id }}"></embed>
53 |                   </div>
54 |                   <form method="post">
55 |                     <input name="nonce" type="hidden" value="{{ Session.nonce }}">
56 |                     <input name="writeup_id" type="hidden" value="{{ writeup.id }}">
57 |                     <textarea name="comment" class="form-control" rows="2" placeholder="Add comment">{{ content }}</textarea>
58 |                     <div class="row col-md-12">
59 |                       <div class="col-md-6">
60 |                         <input name="accepted" type="submit" value="Accept" class="w-100">
61 |                       </div>
62 |                       <div class="col-md-6">
63 |                         <input name="accepted" type="submit" value="Reject" class="w-100">
64 |                       </div>
65 |                     </div>
66 |                   </form>
67 |                 </div>
68 |               </div>
69 |             </div>
70 |             {% endfor %}
71 |           </div>
72 |         </div>
73 |         {% endfor %}
74 |       </div>
75 |     </div>
76 |   </div>
77 | </div>
78 | {% endblock %}
79 | 
80 | {% block scripts %}
81 | <script defer src="{{ url_for('views.themes', path='js/dojo/writeups.js') }}"></script>
82 | {% endblock %}
83 | 


--------------------------------------------------------------------------------
/dojo_theme/templates/base.html:
--------------------------------------------------------------------------------
  1 | {% set dojo_id = dojo.reference_id if dojo else None %}
  2 | {% set module_id = module.id if module else None %}
  3 | 
  4 | <!DOCTYPE html>
  5 | <html>
  6 |   <head>
  7 |     <title>{{ Configs.ctf_name }}</title>
  8 |     <meta charset="utf-8">
  9 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 10 | 
 11 |     <meta property="og:title" content="pwn.college">
 12 |     <meta property="og:description" content="Learn to Hack!">
 13 |     <meta property="og:image" content="{{ url_for('views.themes', path='img/dojo/ninja.png', _external=True) }}">
 14 | 
 15 |     <link rel="icon" href="{{ url_for('views.themes', path='img/favicon.png') }}">
 16 |     <link rel="stylesheet" href="{{ url_for('views.themes', path='css/fonts.css') }}">
 17 |     <link rel="stylesheet" href="{{ url_for('views.themes', path='css/main.css') }}">
 18 |     <link rel="stylesheet" href="{{ url_for('views.themes', path='css/core.css') }}">
 19 |     <link rel="preload" href="{{ url_for('views.themes', path='font/SpaceMono-Regular.ttf') }}" as="font" type="font/ttf" crossorigin="anonymous">
 20 |     <link rel="preload" href="{{ url_for('views.themes', path='font/SpaceMono-Bold.ttf') }}" as="font" type="font/ttf" crossorigin="anonymous">
 21 |     <link rel="preload" href="{{ url_for('views.themes', path='font/SpaceGrotesk-VariableFont_wght.ttf') }}" as="font" type="font/ttf" crossorigin="anonymous">
 22 |     <style>
 23 |       @font-face {
 24 |         font-family: 'Space Mono';
 25 |         src: url("{{ url_for('views.themes', path='font/SpaceMono-Regular.ttf') }}") format('truetype');
 26 |         font-weight: 400;
 27 |         font-style: normal;
 28 |         font-display: swap;
 29 |       }
 30 | 
 31 |       @font-face {
 32 |         font-family: 'Space Mono';
 33 |         src: url("{{ url_for('views.themes', path='font/SpaceMono-Bold.ttf') }}") format('truetype');
 34 |         font-weight: 700;
 35 |         font-style: normal;
 36 |         font-display: swap;
 37 |       }
 38 | 
 39 |       @font-face {
 40 |         font-family: 'Space Grotesk';
 41 |         src: url("{{ url_for('views.themes', path='font/SpaceGrotesk-VariableFont_wght.ttf') }}") format('truetype');
 42 |         font-weight: 100 900;
 43 |         font-style: normal;
 44 |         font-display: swap;
 45 |       }
 46 |     </style>
 47 |     <link rel="stylesheet" href="{{ url_for('views.themes', path='css/custom.css') }}">
 48 |     {% block stylesheets %}
 49 |     {% endblock %}
 50 | 
 51 |     {{ Plugins.styles }}
 52 |     <script type="text/javascript">
 53 |       var init = {
 54 | 	  'urlRoot': "{{ request.script_root }}",
 55 | 	  'csrfNonce': "{{ Session.nonce }}",
 56 | 	  'userMode': "{{ Configs.user_mode }}",
 57 | 	  'userId': {{ Session.id }},
 58 | 	  'start': {{ Configs.start | tojson }},
 59 | 	  'end': {{ Configs.end | tojson }},
 60 | 	  'theme_settings': {{ Configs.theme_settings | tojson }},
 61 |           'dojo': "{{ dojo_id if dojo else '' }}",
 62 |           'module': "{{ module_id if module else '' }}"
 63 |       }
 64 |     </script>
 65 |     {{ Configs.theme_header }}
 66 |   </head>
 67 |   <body>
 68 |     {% include "components/navbar.html" %}
 69 | 
 70 |     <main role="main">
 71 |       {% block content %}
 72 |       {{ content | safe}}
 73 |       {% endblock %}
 74 |     </main>
 75 | 
 76 |     <footer class="footer">
 77 |       <div class="container text-center" style="line-height: 20px; opacity: 0.7">
 78 |         <small>
 79 |           Powered by <strong>pwn.college</strong><br>
 80 |           Interested in dedicated training or tailored services for your organization?
 81 |           <a href="https://llc.pwn.college/">Find out more</a>.
 82 |         </small>
 83 |       </div>
 84 |     </footer>
 85 | 
 86 |     <script defer src="{{ url_for('views.themes', path='js/vendor.bundle.js') }}"></script>
 87 |     <script defer src="{{ url_for('views.themes', path='js/core.js') }}"></script>
 88 |     <script defer src="{{ url_for('views.themes', path='js/helpers.js') }}"></script>
 89 | 
 90 |     {% block entrypoint %}
 91 |     <script defer src="{{ url_for('views.themes', path='js/pages/main.js') }}"></script>
 92 |     {% endblock %}
 93 | 
 94 |     <script defer src="{{ url_for('views.themes', path='js/dojo/util.js') }}"></script>
 95 |     <script defer src="{{ url_for('views.themes', path='js/dojo/navbar.js') }}"></script>
 96 |     <script defer src="{{ url_for('views.themes', path='js/dojo/popup.js') }}"></script>
 97 | 
 98 |     {% block scripts %}
 99 |     {% endblock %}
100 | 
101 |     {{ Plugins.scripts }}
102 | 
103 |     {{ Configs.theme_footer }}
104 |   </body>
105 | </html>
106 | 


--------------------------------------------------------------------------------
/dojo_theme/templates/belts.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | {% block content %}
 4 | <div class="jumbotron">
 5 |   <div class="container">
 6 |     <h1>The Belted</h1>
 7 |   </div>
 8 | </div>
 9 | <div class="container">
10 |   <p>
11 |   The hacker ethos goes beyond the acquisition of a satisfactory grade in a college course.
12 |   A true hacker is never satisfied with the state of their knowledge.
13 |   They strive, or are irresistably driven towards, the achievement of absolute mastery of technical topics.
14 |   </p>
15 | 
16 |   <p>
17 |   Below is a list of true hackers: those who stared at the yellow box, and rather than flinching, dove in.
18 |   </p>
19 | 
20 |   {% for belt_color in ("blue", "green", "yellow", "orange") %}
21 |     <h2>{{belt_color.title()}} Belts</h2>
22 |     <p>
23 |     {% if belt_color == "blue" %}
24 |     It is the rare individual who perseveres against the hardest of challenges, pushing on when the night is at its darkest.
25 |     The hackers below are truly the most stout of spirit, fighting through countless seemingly-impossible challenges and proving themselves worthy to wear their blue belt among the clouds.
26 |     {% elif belt_color == "green" %}
27 |     A sapling grows toward the sun: a hacker emerges into the light.
28 |     These individuals have shown a unique ability to see through the haze of uncertainty to the clarity beyond.
29 |     They are ready to journey into the sky.
30 |     {% elif belt_color == "yellow" %}
31 |     The sky brightens as the sun rises.
32 |     The minds of these students are opening, admitting phenomenal cybersecurity concepts that few even suspect to exist.
33 |     With sunlight comes the possibility of growth and the promise of learning to come.
34 |     {% elif belt_color == "orange" %}
35 |     Dawn is on the horizon.
36 |     No longer do the names written below belong to those unknowing cybersecurity: instead, their owners now realize the vast tracts of concepts still unexplored, waiting ready to expand their minds.
37 |     {% endif %}
38 |     </p>
39 | 
40 |     <ul>
41 |       {% for user_id in belt_data.ranks[belt_color] %}
42 |       {% set user = belt_data.users[user_id] %}
43 |       <li>
44 |         <a class="brand-mono" href="{{ url_for('pwncollege_users.view_other', user_id=user_id) }}">{{ user.handle }}</a>
45 |         {% if user.name %}({{ user.name }}){% endif %}
46 |         {% if user.emoji %}{{ user.emoji }}{% endif %}
47 |         {% if user.site %}
48 |         <a href="{{ user.site }}" target="_blank" style="color: inherit;" rel="noopener">
49 |           <i class="fas fa-external-link-alt" data-toggle="tooltip" data-placement="top"
50 |             title="{{ user.site }}">
51 |           </i>
52 |         </a>
53 |         {% endif %}
54 |         {% if user.mail %}
55 |         <a href="mailto:{{ user.mail }}" style="color: inherit;" rel="noopener">
56 |           <i class="fas fa-external-link-alt" data-toggle="tooltip" data-placement="top"
57 |             title="{{ user.website }}">
58 |           </i>
59 |         </a>
60 |         {% endif %}
61 |         <em>(ascended {{ user.date }})</em>
62 |       </li>
63 |       {% endfor %}
64 |     </ul>
65 |     <br>
66 |   {% endfor %}
67 | 
68 |   <h2>How to get on the above lists</h2>
69 |   You, too, can be listed among the legends above.
70 |   You earn your belts by fully completing the appropriate <a href="{{url_for('pwncollege_dojos.listing')}}">pwn.college dojos</a>.
71 |   This takes skill, cunning, and perseverance, but you can do it.
72 |   Good luck.
73 | </div>
74 | {% endblock %}
75 | 


--------------------------------------------------------------------------------
/dojo_theme/templates/dojo.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | {% from "macros/widgets.html" import card %}
 3 | 
 4 | {% block content %}
 5 | <div class="jumbotron">
 6 |   <div class="container">
 7 |     <h1 class="brand-white brand-mono-bold">{{ dojo.name or dojo.id }}<span class="brand-dot">.</span></h1>
 8 |   </div>
 9 | </div>
10 | <div class="container">
11 |   {% include "components/errors.html" %}
12 | 
13 |   {% if dojo.description %}
14 |   <p>{{ dojo.description | markdown }}</p>
15 |   <br>
16 |   {% endif %}
17 | 
18 |   <div class="row text-center">
19 |     {% if dojo.course and user %}
20 |     <div class="col-lg-auto m-3">
21 |       <figure>
22 |         <a class="text-decoration-none" href="{{ url_for('course.view_course', dojo=dojo.reference_id) }}">
23 |           <i class="fas fa-graduation-cap fa-3x"></i>
24 |           <figcaption><b>Course</b></figcaption>
25 |         </a>
26 |       </figure>
27 |     </div>
28 |     {% endif %}
29 |     {% if dojo_user.type == "admin" or user.type == "admin" %}
30 |     <div class="col-lg-auto m-3">
31 |       <figure>
32 |         <a class="text-decoration-none" href="{{ url_for('pwncollege_dojo.view_dojo_admin', dojo=dojo.reference_id) }}">
33 |           <i class="fas fa-users-cog fa-3x"></i>
34 |           <figcaption><b>Admin</b></figcaption>
35 |         </a>
36 |       </figure>
37 |     </div>
38 |     {% endif %}
39 |   </div>
40 | 
41 |   <br>
42 | 
43 |   {% if dojo.award and dojo.award.get("emoji") %}
44 |   <h2 class="row">Award: <b>{{ dojo.award["emoji"] }}</b></h2>
45 |   <br>
46 |   {% endif %}
47 | 
48 |   {% if dojo.modules %}
49 |   <h2 class="row">Stats</h2>
50 |   {% include "components/stat_dashboard.html" %}
51 |   <div class="row"></div>
52 | 
53 |   <br>
54 | 
55 |   <h2 class="row">Modules</h2>
56 |   <br>
57 |   <ul class="card-list">
58 |     {% for module in dojo.modules %}
59 |     {% set container_count = module_container_counts.get(module.id, 0) %}
60 |     {% set num_challs = module.visible_challenges() | length %}
61 |     {% set num_solved = module.solves(user=user, ignore_visibility=True, ignore_admins=False).count() if user else 0 %}
62 |     {% if module.visible() or dojo.is_admin(user) %}
63 |       {{ card(
64 |         url_for('pwncollege_dojo.view_dojo_path', dojo=dojo_id, path=module.id),
65 | 	title=module.name or module.id,
66 |         text_lines = [
67 |           "{} Hacking".format(container_count) if container_count > 0 else "",
68 |           "{} / {}".format(
69 |             module.solves(user=user, ignore_visibility=True, ignore_admins=False).count() if user else 0,
70 |             module.visible_challenges() | length
71 |           ),
72 | 	  "hidden" if not module.visible()
73 |         ],
74 |         solve_percent=(num_solved / num_challs) * 100 if num_challs else 0,
75 |       ) }}
76 |     {% endif %}
77 |     {% endfor %}
78 |   </ul>
79 | 
80 |   <br>
81 | 
82 |   <h2 class="row" id="scoreboard-heading">30-Day Scoreboard:</h2>
83 |   <br>
84 |   {% from "macros/scoreboard.html" import scoreboard %}
85 |   {{ scoreboard() }}
86 | 
87 |   {% endif %}
88 | </div>
89 | {% endblock %}
90 | 
91 | {% block scripts %}
92 | <script defer onload="loadScoreboard(30, 1);" src="{{ url_for('views.themes', path='js/dojo/scoreboard.js') }}"></script>
93 | <script defer src="{{ url_for('views.themes', path='js/dojo/copy.js') }}"></script>
94 | <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
95 | {% endblock %}
96 | 


--------------------------------------------------------------------------------
/dojo_theme/templates/dojo_activity.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | {% block content %}
 4 | <div class="jumbotron">
 5 |     <div class="container">
 6 |         <h1>Dojo Activity</h1>
 7 |     </div>
 8 | </div>
 9 | <div class="container">
10 |     <h2>Active Challenges</h2>
11 |     {% if actives %}
12 |     <table class="table">
13 |         <thead>
14 |             <tr>
15 |                 <th>User</th>
16 |                 <th>Challenge</th>
17 |                 <th>Uptime</th>
18 |             </tr>
19 |         </thead>
20 |         <tbody>
21 |             {% for active in actives %}
22 |             <tr>
23 |                 <td><a href="{{ generate_account_url(active.user.id, admin=True) }}">{{ active.user.name }}</a></td>
24 |                 <td>{{ active.challenge.module.name }} - {{ active.challenge.name}}</td>
25 |                 <td>{{ active.uptime.days }}d {{ active.uptime.seconds // 3600 }}h {{ (active.uptime.seconds // 60) % 60 }}m</td>
26 |             </tr>
27 |             {% endfor %}
28 |         </tbody>
29 |     </table>
30 |     {% else %}
31 |     <p>No active challenges at the moment.</p>
32 |     {% endif %}
33 | </div>
34 | {% endblock %}
35 | 


--------------------------------------------------------------------------------
/dojo_theme/templates/dojo_admin.html:
--------------------------------------------------------------------------------
  1 | {% extends "base.html" %}
  2 | 
  3 | {% block content %}
  4 | <div class="jumbotron">
  5 |   <div class="container">
  6 |     <h1>Dojo Admin</h1>
  7 |     <br>
  8 |     <h2>{{ dojo.name }}</h2>
  9 |   </div>
 10 | </div>
 11 | <div class="container">
 12 |   <div id="dojo-delete-results" class="form-group">
 13 |   <div class="row text-center">
 14 |     <div class="col-lg-auto m-3">
 15 |       <figure>
 16 |       <a class="text-decoration-none" href="#"
 17 |         data-copy="{{ url_for('pwncollege_dojo.join_dojo', dojo=dojo.reference_id, password=dojo.password, _external=True) }}"
 18 |         onclick="copyToClipboard(event)">
 19 |         <i class="fas fa-share fa-3x"></i>
 20 |         <figcaption><b id="tooltip">&nbsp;Share&nbsp;</b></figcaption>
 21 |       </a>
 22 |       </figure>
 23 |     </div>
 24 |     <div class="col-lg-auto m-3">
 25 |       <figure>
 26 |       <a class="text-decoration-none" href="{{ url_for('pwncollege_dojo.update_dojo', dojo=dojo.reference_id, update_code=dojo.update_code) }}" target="_blank">
 27 |         <i class="fas fa-upload fa-3x"></i>
 28 |         <figcaption><b>Update</b></figcaption>
 29 |       </a>
 30 |       </figure>
 31 |     </div>
 32 |     {% if is_admin() %}
 33 |     <div class="col-lg-auto m-3">
 34 |       <figure>
 35 |         <a id="dojo-delete-button" class="text-decoration-none delete-link" href="#" data-dojo="{{ dojo.reference_id }}">
 36 |           <i class="fas fa-trash fa-3x"></i>
 37 |           <figcaption><b>Delete</b></figcaption>
 38 |         </a>
 39 |       </figure>
 40 |     </div>
 41 |     {% endif %}
 42 |     <div class="col-lg-auto m-3">
 43 |       <figure>
 44 |       <a class="text-decoration-none" href="{{ url_for('pwncollege_dojo.dojo_solves', dojo=dojo.reference_id, solves_code=dojo.solves_code, format='csv') }}">
 45 |         <i class="fas fa-file-csv fa-3x"></i>
 46 |         <figcaption><b>Solves</b></figcaption>
 47 |       </a>
 48 |       </figure>
 49 |     </div>
 50 |     {% if dojo.course %}
 51 |     <div class="col-lg-auto m-3">
 52 |       <figure>
 53 |       <a class="text-decoration-none" href="{{ url_for('course.view_all_grades', dojo=dojo.reference_id) }}">
 54 |         <i class="fas fa-signal fa-3x"></i>
 55 |         <figcaption><b>Grades</b></figcaption>
 56 |       </a>
 57 |       </figure>
 58 |     </div>
 59 |     {% endif %}
 60 |   </div>
 61 |   <div>
 62 |     <form method="post" id="dojo-award-prune-form" autocomplete="off">
 63 |       <div class="form-group">
 64 |         <input class="btn btn-mini btn-primary" id="_submit" name="_submit" type="submit" value="Prune Legacy Emoji Awards">
 65 |       </div>
 66 |       <div id="dojo-award-prune-results" class="form-group">
 67 |       </div>
 68 |     </form>
 69 |     {% if is_admin() %}
 70 |     <form method="post" id="dojo-promote-dojo-form" autocomplete="off">
 71 |       <div class="form-group">
 72 |         <input class="btn btn-mini btn-primary" id="_submit" name="_submit" type="submit" value="Make This Dojo Official">
 73 |       </div>
 74 |       <div id="dojo-promote-dojo-results" class="form-group">
 75 |       </div>
 76 |     </form>
 77 |     {% endif %}
 78 |   </div>
 79 |   <b>Reference ID: </b><code>{{ dojo.reference_id }}</code>
 80 |   <br>
 81 |   <b>Dojo ID: </b><code>{{ dojo.hex_dojo_id }}</code>
 82 |   <br>
 83 |   <!-- <b>Update Code: </b><code>{{ dojo.update_code }}</code>
 84 |   <br> -->
 85 |   <b>Git Hash: </b><code>{{ dojo.hash[:8] }}</code>
 86 |   <br>
 87 |   <b>Admins</b>
 88 |   <ul>
 89 |     {% for admin in dojo.admins %}
 90 |     <li>{{ admin.user.name }}</li>
 91 |     {% endfor %}
 92 |   </ul>
 93 |   <b>Members</b>
 94 |   <form method="post" id="dojo-promote-admin-form" autocomplete="off">
 95 |     <div class="form-group">
 96 |       {% for member in dojo.members %}
 97 |       <input type="radio" id="{{ member.user.id }}" name="user_id" value="{{ member.user.id }}">
 98 |       <label for="{{ member.user.id }}"><a href="{{ url_for('pwncollege_users.view_other', user_id=member.user.id) }}"><span id="name-for-{{member.user.id}}">{{ member.user.name }}</span></a></label>
 99 |       <br>
100 |       {% endfor %}
101 |       <input class="btn btn-mini btn-primary" id="_submit" name="_submit" type="submit" value="Promote to Admin">
102 |     </div>
103 |     <div id="dojo-promote-admin-results" class="form-group">
104 |     </div>
105 |   </form>
106 | </div>
107 | {% endblock %}
108 | 
109 | {% block entrypoint %}
110 |     <script defer src="{{ url_for('views.themes', path='js/pages/settings.js') }}"></script>
111 | {% endblock %}
112 | 
113 | {% block scripts %}
114 | <script defer src="{{ url_for('views.themes', path='js/dojo/settings.js') }}"></script>
115 | {% endblock %}
116 | 


--------------------------------------------------------------------------------
/dojo_theme/templates/dojo_admin_user.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | 
 4 | {% block stylesheets %}
 5 | <style>
 6 |   .setup-complete::before, .setup-incomplete::before, .setup-unknown::before {
 7 |       position: absolute;
 8 |       left: 10px;
 9 |       font-size: 24px;
10 |       line-height: 1;
11 |   }
12 | 
13 |   .setup-incomplete::before {
14 |     content: '✗';
15 |     color: rgb(244, 67, 54);
16 |   }
17 | 
18 |   .setup-complete::before {
19 |     content: '✓';
20 |     color: rgb(76, 175, 80);
21 |   }
22 | 
23 |   .setup-unknown::before {
24 |     content: '?';
25 |     color: rgb(255, 193, 7);
26 |   }
27 | </style>
28 | {% endblock %}
29 | 
30 | 
31 | {% block content %}
32 | <div class="jumbotron">
33 |   <div class="container">
34 |     <h1>{{ dojo.name }} User Info for {{ user.name }}</h1>
35 |   </div>
36 | </div>
37 | <div class="container">
38 |   <div class="row">
39 |     <div class="col-md-8 offset-md-1">
40 |       <ul>
41 |         <li>
42 |           pwn.college User Name: {{ user.name }}
43 |         </li>
44 |         <li>
45 |           {{ identity_name }} : {{ identity_value }}
46 |         </li>
47 |         <li>
48 |           {% if discord_member %}
49 |             Authorized and linked Discord Username: {{ discord_member.user.username }} <br>
50 |             Discord ID (unique): {{ discord_member.user.id }}
51 |           {% endif %}
52 |         </li>
53 |       </ul>
54 |     </div>
55 |   </div>
56 | </div>
57 | {% endblock %}
58 | 
59 | 


--------------------------------------------------------------------------------
/dojo_theme/templates/dojo_create.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | {% from "macros/widgets.html" import card %}
 3 | 
 4 | {% block content %}
 5 | <div class="jumbotron">
 6 |     <div class="container">
 7 |         <h1>Create Dojo</h1>
 8 |     </div>
 9 | </div>
10 | <div class="container">
11 |   <p>pwn.college dojos are defined in a git repository. You can use the example repositories listed below, or our <a href="https://github.com/pwncollege/official-dojos">official dojo repositories</a>, for examples on how to build a dojo!</p>
12 |     <ul class="card-list">
13 |       {% for dojo in example_dojos %}
14 |       {% set num_challenges = (dojo.challenges | length) %}
15 |       {{ card(url_for("pwncollege_dojo.view_dojo", dojo=dojo.reference_id),
16 |       title=dojo.name,
17 |       text_lines = [
18 |         "{} Modules".format(dojo.modules | length),
19 |         "{} Challenges".format(num_challenges),
20 |       ],
21 |       icon=url_for("pwncollege_belts.view_belt", color=dojo.award.belt) if (dojo.award.belt and dojo.official) else None,
22 |       emoji=dojo.award.emoji,
23 |       solve_percent=(((dojo.solves(user=user, ignore_visibility=True, ignore_admins=False).count() if user else 0) / num_challenges) * 100) if num_challenges else 0,
24 |       ) }}
25 |       {% endfor %}
26 |     </ul>
27 |   <p>When you are ready, create your dojo from your repository using the form below!</p>
28 |     <form method="post" id="dojo-create-form" autocomplete="off">
29 |         <div class="form-group">
30 |             <b><label>GitHub Repository</label></b>
31 |             <small class="form-text text-muted">https://github.com/<b>pwncollege/example-dojo</b></small>
32 |             <br>
33 |             <input class="form-control" name="repository" type="text" placeholder="pwncollege/example-dojo" value="">
34 | 
35 |             <br>
36 | 
37 |             <b><label>Deploy Key</label></b>
38 |             <small class="form-text text-muted">
39 |             Required for Private Repositories: <a href="https://docs.github.com/en/developers/overview/managing-deploy-keys#deploy-keys" target="_blank">Deploy Keys Documentation</a>
40 |             </small>
41 |             <br>
42 |             <div class="input-group mb-3">
43 |                 <input class="form-control" name="public_key" type="text" value="{{ public_key }}" readonly>
44 |                 <div class="input-group-append copy-button">
45 |                     <button class="btn btn-outline-secondary" type="button">
46 |                         <i class="fas fa-clipboard"></i>
47 |                     </button>
48 |                 </div>
49 |             </div>
50 | 
51 |             <input class="form-control" name="private_key" type="hidden" value="{{ private_key }}">
52 |         </div>
53 | 
54 |         <br>
55 | 
56 |         <div id="dojo-create-results" class="form-group">
57 |         </div>
58 | 
59 |         <div class="form-group text-right">
60 |             <input class="btn btn-md btn-primary btn-outlined" id="_submit" name="_submit" type="submit" value="Create">
61 |         </div>
62 |     </form>
63 | </div>
64 | {% endblock %}
65 | 
66 | {% block entrypoint %}
67 |     <script defer src="{{ url_for('views.themes', path='js/pages/settings.js') }}"></script>
68 | {% endblock %}
69 | 
70 | {% block scripts %}
71 | <script defer src="{{ url_for('views.themes', path='js/dojo/settings.js') }}"></script>
72 | {% endblock %}
73 | 


--------------------------------------------------------------------------------
/dojo_theme/templates/dojos.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | {% from "macros/widgets.html" import card %}
 3 | {% from "macros/widgets.html" import dojo_grid %}
 4 | 
 5 | {% block content %}
 6 | <div class="container">
 7 |   <p><br><br>
 8 |   <h2>Getting Started</h2>
 9 | 
10 |   {{ dojo_grid(categorized_dojos["welcome"], dojo_container_counts) }}
11 | 
12 |   <p><br><br>
13 |   <h2>Core Material</h2>
14 | 
15 |   {{ dojo_grid(categorized_dojos["topic"], dojo_container_counts) }}
16 | 
17 |   <p><br><br>
18 |   <h2>Community Material</h2>
19 | 
20 |   {{ dojo_grid(categorized_dojos["public"], dojo_container_counts) }}
21 | 
22 |   <p><br><br>
23 |   <h2>The Courses</h2>
24 | 
25 |   {{ dojo_grid(categorized_dojos["course"], dojo_container_counts) }}
26 | 
27 |   {% if categorized_dojos["member"] %}
28 |   <p><br><br>
29 |   <h2>Dojos You've Joined</h2>
30 | 
31 |   {{ dojo_grid(categorized_dojos["member"], dojo_container_counts) }}
32 |   {% endif %}
33 | 
34 |   <p><br><br>
35 |   <h2>Your Dojos</h2>
36 | 
37 |   {{ dojo_grid(categorized_dojos["admin"], dojo_container_counts, create_icon=True) }}
38 | 
39 | </div>
40 | {% endblock %}
41 | 
42 | {% block scripts %}
43 | {% endblock %}
44 | 


--------------------------------------------------------------------------------
/dojo_theme/templates/iframe.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | {% block stylesheets %}
 4 | {{ super() }}
 5 | <style>
 6 |   html, body {
 7 |       margin: 0;
 8 |       height: 100%;
 9 |       min-height: 100%;
10 |   }
11 |   body {
12 |       display: flex;
13 |       flex-direction: column;
14 |   }
15 |   nav, footer {
16 |       flex: none;
17 |   }
18 |   main {
19 |       flex: auto;
20 |       margin-bottom: 0px;
21 |   }
22 |   iframe {
23 |       height: 100%;
24 |       width: 100%;
25 |       overflow: hidden;
26 |       border: none;
27 |   }
28 |   .inactive {
29 |       height: 50%;
30 |       display: flex;
31 |       flex-direction: column;
32 |       justify-content: center;
33 |       text-align: center;
34 |   }
35 | </style>
36 | {% endblock %}
37 | 
38 | {% block content %}
39 | {% if active %}
40 | <iframe id="workspace_iframe" name="{{ iframe_name }}" src="{{ iframe_src }}"></iframe>
41 | {% else %}
42 | <h1 class="inactive">No active challenge session; start a challenge!</h1>
43 | {% endif %}
44 | {% endblock %}
45 | 
46 | {% block scripts %}
47 | {{ super() }}
48 | 
49 | {% endblock %}


--------------------------------------------------------------------------------
/dojo_theme/templates/macros/scoreboard.html:
--------------------------------------------------------------------------------
 1 | {% macro scoreboard() -%}
 2 | <div class="scoreboard-controls row">
 3 |   <p>
 4 |   <span id="scoreboard-control-week"><a href="javascript:loadScoreboard(7, 1)">7-Day</a></span> |
 5 |   <span id="scoreboard-control-month"><a href="javascript:loadScoreboard(30, 1)">30-Day</a></span> |
 6 |   <span id="scoreboard-control-all"><a href="javascript:loadScoreboard(0, 1)">All-Time</a></span>
 7 |   </p>
 8 | </div>
 9 | <div class="scoreboard row">
10 |   <div class="col-md-12 p-0">
11 |     <table class="table table-striped">
12 | 	    <thead>
13 | 	      <tr>
14 | 	        <td scope="col" class="col-md-1"><b>Rank</b></td>
15 |           <td scope="col" class="col-md-1"></td>
16 | 	        <td scope="col" class="col-md-4"><b>Hacker</b></td>
17 | 	        <td scope="col" class="col-md-4"><b>Badges</b></td>
18 | 	        <td scope="col" class="col-md-1"></td>
19 | 	        <td scope="col" class="col-md-1"><b>Score</b></td>
20 | 	      </tr>
21 | 	    </thead>
22 | 	    <tbody id="scoreboard">
23 | 	    </tbody>
24 |     </table>
25 |   </div>
26 |   <div>
27 |     <ul id="scoreboard-pages" class="p-0">
28 |     </ul>
29 |   </div>
30 | </div>
31 | {%- endmacro %}
32 | 


--------------------------------------------------------------------------------
/dojo_theme/templates/macros/widgets.html:
--------------------------------------------------------------------------------
  1 | {% macro navitem(name, url, icon, new=False, shrink=False) %}
  2 | <li class="nav-item">
  3 |   {% if not new %}
  4 |   <a class="nav-link" href="{{ url }}">
  5 |   {% else %}
  6 |   <a class="nav-link" href="{{ url }}" target="_blank">
  7 |   {% endif %}
  8 |     <span class="d-block" data-toggle="tooltip" data-placement="bottom" title="{{ name }}">
  9 |       <i class="fas {{ icon }} d-none d-md-block d-lg-none" style="width: 20px"></i>
 10 |     </span>
 11 |     <span class="d-sm-block d-md-none d-lg-block text-nowrap">
 12 |       <i class="fas {{ icon }} pr-1"></i>
 13 |       {% if not shrink %}
 14 |       {{ name }}
 15 |       {% else %}
 16 |       <span class="d-lg-none">{{ name }}</span>
 17 |       {% endif %}
 18 |     </span>
 19 |   </a>
 20 | </li>
 21 | {% endmacro %}
 22 | 
 23 | {% macro card(url, title=None, text_lines=None, icon=None, emoji=None, custom=False, solve_percent=0, course=False) -%}
 24 |   <a class="text-decoration-none" href="{{ url }}">
 25 |     <li class="card card-small">
 26 |       <div class="card-body">
 27 |         {% if title %}<h4 class="card-title">{{ title }}</h4>{% endif %}
 28 |         {% if icon or emoji %}
 29 |         <div class="card-icon">
 30 |           {% if icon %}<img src="{{ icon }}">{% endif %}
 31 |           {% if emoji %}{{ emoji }}{% endif %}
 32 |         </div>
 33 |         {% endif %}
 34 |         {% if text_lines %}<p class="card-text">{% for text in text_lines %}{{ text }}<br>{% endfor %}</p>{% endif %}
 35 |         {% if custom %}{{ caller() }}{% endif %}
 36 |         {% if not course %}
 37 |         <div class="progress-bar" style="width: {{solve_percent}}%">
 38 |           {% if solve_percent != 0 %}
 39 |             <span class="progress-bar-text">{{solve_percent|round(0, 'floor')|int}}%</span>
 40 |           {% endif %}
 41 |         </div>
 42 |         {% endif %}
 43 |       </div>
 44 |     </li>
 45 |   </a>
 46 | {%- endmacro %}
 47 | 
 48 | {% macro accordion_item(accordion_id, item_id, is_disabled) %}
 49 |   <div class="accordion-item">
 50 |     <div class="accordion-item-header" id="{{ accordion_id }}-header-{{ item_id }}">
 51 |       <h2 class="mb-0 button-wrapper">
 52 |         <button id="{{ accordion_id }}-header-button-{{ item_id }}" class="btn btn-link text-decoration-none w-100 challenge-button-2 collapsed {% if is_disabled %}disabled{% endif %}" type="button" data-toggle="collapse" data-target="#{{ accordion_id }}-body-{{ item_id }}" aria-expanded="false" aria-controls="{{ accordion_id }}-body-{{ item_id }}">
 53 |           {{ caller(True) }}
 54 |         </button>
 55 |       </h2>
 56 |     </div>
 57 | 
 58 |     <div id="{{ accordion_id }}-body-{{ item_id }}" class="collapse" aria-labelledby="{{ accordion_id }}-header-{{ item_id }}" data-parent="#{{ accordion_id }}">
 59 |       <div class="accordion-item-body">
 60 |         {{ caller(False) }}
 61 |       </div>
 62 |     </div>
 63 |   </div>
 64 | {% endmacro %}
 65 | 
 66 | {% set svg_add_icon %}
 67 | <svg class="w-100 h-100">
 68 |   <circle cx="50%" cy="50%" r="30%" stroke="gray" fill="none" stroke-width="8" stroke-dasharray="8"></circle>
 69 |   <g stroke="gray" stroke-width="8">
 70 |     <line x1="50%" y1="30%" x2="50%" y2="70%"></line>
 71 |     <line x1="30%" y1="50%" x2="70%" y2="50%"></line>
 72 |   </g>
 73 | </svg>
 74 | {% endset %}
 75 | 
 76 | {% macro dojo_grid(dojos, dojo_container_counts, create_icon=None) -%}
 77 |   <ul class="card-list">
 78 |     {% for dojo, solves in dojos %}
 79 |       {% set icon = url_for("pwncollege_belts.view_belt", color=dojo.award.belt) if (dojo.award.belt and dojo.official) else None %}
 80 |       {% set solve_percent = (solves / dojo.challenges_count) * 100 if dojo.challenges_count else 0 %}
 81 |       {{ card(
 82 |         url_for("pwncollege_dojo.view_dojo", dojo=dojo.reference_id),
 83 |         title=dojo.name or dojo.id,
 84 |         text_lines=[
 85 |           "{} Hacking".format(dojo_container_counts.get(dojo.reference_id, 0)) if dojo_container_counts.get(dojo.reference_id, 0) else "",
 86 |           "{} Module{}".format(dojo.modules_count, "" if dojo.modules_count == 1 else "s"),
 87 |           "{} Challenge{}".format(dojo.challenges_count, "" if dojo.challenges_count == 1 else "s"),
 88 |         ],
 89 |         icon=icon,
 90 |         emoji=dojo.award.emoji,
 91 |         solve_percent=solve_percent,
 92 |         course=dojo.course,
 93 |       ) }}
 94 |     {% endfor %}
 95 |     {% if create_icon %}
 96 |       {% call card(url_for("pwncollege_dojos.dojo_create"), custom=True) %}
 97 |         {{ svg_add_icon }}
 98 |       {% endcall %}
 99 |     {% endif %}
100 |   </ul>
101 | {%- endmacro %}
102 | 


--------------------------------------------------------------------------------
/dojo_theme/templates/markdown.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | {% block content %}
 4 | <div class="jumbotron">
 5 |   <div class="container">
 6 |     <h1>{{ dojo.name or dojo.id }}</h1>
 7 |   </div>
 8 | </div>
 9 | <div class="container">
10 |   {{ content }}
11 | </div>
12 | {% endblock %}
13 | 


--------------------------------------------------------------------------------
/dojo_theme/templates/register.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | {% block content %}
 4 | <div class="jumbotron">
 5 | 	<div class="container">
 6 | 		<h1>Register</h1>
 7 | 	</div>
 8 | </div>
 9 | <div class="container">
10 | 	<div class="row">
11 | 		<div class="col-md-6 offset-md-3">
12 | 			{% include "components/errors.html" %}
13 | 
14 | 			<h2>Ground Rules</h2>
15 | 			<p>When using this platform, please keep several ground rules in mind!</p>
16 | 			<h3>Writeups</h3>
17 | 			<p>The challenges created for pwn.college are educational material, and are used to grade students at Arizona State University.
18 |       Because of this, we would appreciate that writeups, walkthrough videos, and livestreams of challenge solutions are not posted to the internet.
19 |       Obviously, we can't stop you from posting things to the internet, but we worked hard to make all of this public, and we would appreciate your help in keeping pwn.college a viable educational platform.</p>
20 |       <h3>Bug Bounties</h3>
21 |       <p>Even master hackers have vulnerabilities in their software!
22 |       If you find a vulnerability in this platform, please <a href="mailto:pwn-college@asu.edu">email</a> us rather than pwn us.
23 |       We'll appreciate it, and you'll get extra credit (if you're an ASU student) or an awesome scoreboard award!</p>
24 | 
25 |       <h2>Sign Up!</h2>
26 | 			{% with form = Forms.auth.RegistrationForm() %}
27 | 			{% from "macros/forms.html" import render_extra_fields %}
28 | 			<form method="post" accept-charset="utf-8" autocomplete="off" role="form">
29 | 				<div class="form-group">
30 | 					<b>{{ form.name.label }}</b>
31 | 					{{ form.name(class="form-control", value=name) }}
32 | 					<small class="form-text text-muted">
33 | 						Your username on the site
34 | 					</small>
35 | 				</div>
36 | 				<div class="form-group">
37 | 					<b>{{ form.email.label }}</b>
38 | 					{{ form.email(class="form-control", value=email) }}
39 | 					<small class="form-text text-muted">
40 | 						Never shown to the public
41 | 					</small>
42 | 				</div>
43 | 				<div class="form-group">
44 | 					<b>{{ form.password.label }}</b>
45 | 					{{ form.password(class="form-control", value=password) }}
46 | 					<small class="form-text text-muted">
47 | 						Password used to log into your account
48 | 					</small>
49 | 				</div>
50 | 				{{ form.nonce() }}
51 | 
52 | 				{{ render_extra_fields(form.extra) }}
53 | 
54 | 				<div class="row pt-3">
55 | 					<div class="col-md-12">
56 | 						{{ form.submit(class="btn btn-md btn-primary btn-outlined float-right") }}
57 | 					</div>
58 | 				</div>
59 | 
60 | 				{% if Configs.tos_or_privacy %}
61 | 				<div class="row pt-3">
62 | 					<div class="col-md-12 text-center">
63 | 						<small class="text-muted text-center">
64 | 							By registering, you agree to the
65 | 							<a href="{{ Configs.privacy_link }}" rel="noopener" target="_blank">privacy policy</a>
66 | 							and <a href="{{ Configs.tos_link }}" rel="noopener" target="_blank">terms of service</a>
67 | 						</small>
68 | 					</div>
69 | 				</div>
70 | 				{% endif %}
71 | 			</form>
72 | 			{% endwith %}
73 | 		</div>
74 | 	</div>
75 | </div>
76 | {% endblock %}
77 | 
78 | {% block scripts %}
79 | {% endblock %}
80 | 


--------------------------------------------------------------------------------
/dojo_theme/templates/research.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | {% block content %}
 4 | <div class="jumbotron">
 5 |   <div class="container">
 6 |     <h1 class="brand-mono">Research</h1>
 7 |   </div>
 8 | </div>
 9 | <div class="container">
10 |   <p>
11 |     If you would like to opt-out of the ongoing reseasrch studies taking place on the pwn.college platform, simply send an email to <a href="mailto:research@pwn.college">research@pwn.college</a> with the subject line <code>Research Opt-Out Request</code> from the email you are registered on the platform with, otherwise you may be asked for more details to process your request. You are not required to provide a reason for wanting to opt-out, and there will be no penalties for doing so.
12 |   </p>
13 | </div>
14 | {% endblock %}
15 | 


--------------------------------------------------------------------------------
/dojo_theme/templates/workspace.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | {% block stylesheets %}
 4 | {{ super() }}
 5 | <style>
 6 |     html, body {
 7 |         margin: 0;
 8 |         height: 100%;
 9 |         min-height: 100%;
10 |     }
11 |     body {
12 |         display: flex;
13 |         flex-direction: column;
14 |     }
15 |     nav, footer {
16 |         flex: none;
17 |     }
18 |     main {
19 |         flex: auto;
20 |         margin-bottom: 0px;
21 |     }
22 |     iframe {
23 |         height: 100%;
24 |         width: 100%;
25 |         overflow: hidden;
26 |         border: none;
27 |     }
28 |     .inactive {
29 |         height: 50%;
30 |         display: flex;
31 |         flex-direction: column;
32 |         justify-content: center;
33 |         text-align: center;
34 |     }
35 | </style>
36 | {% endblock %}
37 | 
38 | {% block content %}
39 | 
40 | <iframe id="workspace_iframe" name="{{ iframe_name }}" src="" class="d-none"></iframe>
41 | <h1 class="inactive">Loading...</h1>
42 | 
43 | {% endblock %}
44 | 
45 | {% block scripts %}
46 | {{ super() }}
47 | 
48 | <script>
49 |     let response =  fetch("/pwncollege_api/v1/workspace?service={{ service }}").then(response => response.json()).then(data => {
50 |         console.log(data);
51 |         if (data.active) {
52 |             document.getElementById("workspace_iframe").src = data.iframe_src;
53 |             document.querySelector("h1").classList.add("d-none");
54 |             document.getElementById("workspace_iframe").classList.remove("d-none");
55 |         }
56 |         else {
57 |             document.querySelector("h1").innerText = "No active challenge session; start a challenge!";
58 |         }
59 |     }).catch(error => {
60 |         document.querySelector("h1").innerText= `Error while retrieving IFrame Url: ${error}`;
61 |     });
62 | </script>
63 | {% endblock %}


--------------------------------------------------------------------------------
/dojo_theme/templates/writeups.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | 
 3 | {% block stylesheets %}
 4 | <style>
 5 |   .embed-responsive-a {
 6 |       padding-top: 141.42%;
 7 |   }
 8 | 
 9 |   .comment {
10 |       border-color: inherit;
11 |       box-shadow: inherit;
12 |   }
13 | </style>
14 | {% endblock %}
15 | 
16 | {% block content %}
17 | <div class="jumbotron">
18 |   <div class="container">
19 |     <h1>Writeups</h1>
20 |   </div>
21 | </div>
22 | <div class="container">
23 |   <div class="row">
24 |     <div class="col-md-2 offset-md-1">
25 |       <div class="nav flex-column nav-pills" role="tablist">
26 |         <a class="nav-link active" id="upload-tab" data-toggle="pill" href="#writeups-upload" role="tab">Upload</a>
27 |         {% for week in weeks %}
28 | 	<a class="nav-link" id="writeups-week{{ loop.index }}-tab" data-toggle="pill" href="#writeups-week{{ loop.index }}" role="tab">Writeup #{{ loop.index }}</a>
29 |         {% endfor %}
30 |       </div>
31 |     </div>
32 |     <div class="col-md-8">
33 |       <div class="tab-content" id="v-pills-tabContent">
34 | 	<div class="tab-pane fade show active" id="writeups-upload" role="tabpanel">
35 |           <h2>Upload</h2>
36 |           <br>
37 |           {% if countdown %}
38 |           <h3>{{ countdown }}</h3>
39 |           <br>
40 |           {% endif %}
41 |           <form method="post" enctype="multipart/form-data">
42 |             <div class="row">
43 |               <input name="nonce" type="hidden" value="{{ Session.nonce }}">
44 | 	      <div class="col-md-6">
45 |                 <input type="file" name="writeup" accept="application/pdf">
46 |               </div>
47 | 	      <div class="col-md-6">
48 |                 <input type="submit" value="Upload">
49 |               </div>
50 |             </div>
51 |           </form>
52 |         </div>
53 |         {% for week, (writeup, comment) in weeks.items() %}
54 | 	<div class="tab-pane fade" id="writeups-week{{ loop.index }}" role="tabpanel">
55 |           <h2>Writeup #{{ loop.index }}</h2>
56 |           <br>
57 |           {% if writeup %}
58 |           {% if comment %}
59 |           <h3>{{ "Accepted" if comment.accepted else "Rejected" }}</h3>
60 |           {% endif %}
61 |           <div class="embed-responsive embed-responsive-a">
62 |             <embed data-src="/writeups/{{ writeup.id }}">
63 |           </div>
64 |           {% if comment %}
65 |           <textarea readonly class="form-control comment" rows="2">{{ comment.content }}</textarea>
66 |           {% endif %}
67 |           {% endif %}
68 |         </div>
69 |         {% endfor %}
70 |       </div>
71 |     </div>
72 |   </div>
73 | </div>
74 | {% endblock %}
75 | 
76 | {% block scripts %}
77 | <script defer src="{{ url_for('views.themes', path='js/dojo/writeups.js') }}"></script>
78 | {% endblock %}
79 | 


--------------------------------------------------------------------------------
/dojofs/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM python:3.12-slim
 2 | 
 3 | RUN apt-get update && \
 4 |     apt-get install -y \
 5 |         fuse && \
 6 |     rm -rf /var/lib/apt/lists/* && \
 7 |     pip install \
 8 |         docker \
 9 |         fusepy && \
10 |     mkdir -p /run/dojofs/workspace
11 | 
12 | COPY ./dojofs /usr/local/bin/dojofs
13 | 
14 | CMD ["dojofs", "/run/dojofs/workspace"]
15 | 


--------------------------------------------------------------------------------
/dojofs/dojofs:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | 
  3 | import stat
  4 | import sys
  5 | import time
  6 | from datetime import datetime
  7 | from pathlib import Path
  8 | 
  9 | import fuse
 10 | import docker
 11 | from fuse import FUSE, Operations, fuse_get_context
 12 | 
 13 | 
 14 | docker_client = docker.from_env()
 15 | 
 16 | 
 17 | class DojoFS(Operations):
 18 |     def __init__(self):
 19 |         self.files = {}
 20 | 
 21 |     def path(self, path):
 22 |         def decorator(cls):
 23 |             self.files[path] = cls()
 24 |             return cls
 25 |         return decorator
 26 | 
 27 |     def getattr(self, path, fh=None):
 28 |         if path == "/":
 29 |             return dict(st_mode=(stat.S_IFDIR | 0o755), st_nlink=2)
 30 |         file = self.files.get(path)
 31 |         if not file:
 32 |             raise fuse.FuseOSError(fuse.errno.ENOENT)
 33 |         return file.getattr(path, fh)
 34 | 
 35 |     def readdir(self, path, fh):
 36 |         if path == "/":
 37 |             return [".", "..", *(path.lstrip("/") for path, file in self.files.items() if file)]
 38 |         else:
 39 |             raise fuse.FuseOSError(fuse.errno.ENOENT)
 40 | 
 41 |     def read(self, path, size, offset, fh):
 42 |         file = self.files.get(path)
 43 |         if not file:
 44 |             raise fuse.FuseOSError(fuse.errno.ENOENT)
 45 |         return file.read(path, size, offset, fh)
 46 | 
 47 | 
 48 | dojo_fs = DojoFS()
 49 | 
 50 | 
 51 | def get_container_context():
 52 |     uid, gid, pid = fuse_get_context()
 53 |     import pathlib
 54 |     import re
 55 | 
 56 |     container_re = re.compile(r"/containers/([0-9a-f]+)/hostname")
 57 |     mount_info = pathlib.Path(f"/proc/{pid}/mountinfo").read_text()
 58 |     container_id = match.group(1) if (match := container_re.search(mount_info)) else None
 59 |     if not container_id:
 60 |         return None
 61 | 
 62 |     try:
 63 |         container = docker_client.containers.get(container_id)
 64 |     except docker.errors.NotFound:
 65 |         return None
 66 |     return container
 67 | 
 68 | 
 69 | def unix_time(timestamp):
 70 |     if "." in timestamp:
 71 |         timestamp = timestamp[:timestamp.index(".") + 7] + "Z"
 72 |     created_time = datetime.strptime(timestamp, "%Y-%m-%dT%H:%M:%S.%fZ")
 73 |     created_unix_time = time.mktime(created_time.timetuple())
 74 |     return created_unix_time
 75 | 
 76 | 
 77 | @dojo_fs.path("/privileged")
 78 | class PrivilegedFile:
 79 |     def getattr(self, path, fh=None):
 80 |         container = get_container_context()
 81 |         created_unix_time = unix_time(container.attrs["Created"])
 82 |         return dict(
 83 |             st_mode=(stat.S_IFREG | 0o444),
 84 |             st_nlink=1,
 85 |             st_size=4096,
 86 |             st_ctime=created_unix_time,
 87 |             st_mtime=created_unix_time,
 88 |             st_atime=created_unix_time,
 89 |         )
 90 | 
 91 |     def read(self, path, size, offset, fh):
 92 |         container = get_container_context()
 93 |         mode = container.labels.get("dojo.mode")
 94 |         content = b"1\n" if mode == "privileged" else b"0\n"
 95 |         return content[offset:offset + size]
 96 | 
 97 |     def __bool__(self):
 98 |         container = get_container_context()
 99 |         return bool(container)
100 | 
101 | 
102 | if __name__ == "__main__":
103 |     if len(sys.argv) != 2:
104 |         print(f"Usage: {sys.argv[0]} <mountpoint>")
105 |         sys.exit(1)
106 | 
107 |     mountpoint = sys.argv[1]
108 |     Path(mountpoint).mkdir(parents=True, exist_ok=True)
109 |     dojo_fs.__class__.__name__ = "dojofs"
110 |     FUSE(dojo_fs, mountpoint, foreground=True, allow_other=True)
111 | 


--------------------------------------------------------------------------------
/etc/systemd/system/pwn.college.backup.service:
--------------------------------------------------------------------------------
1 | [Unit]
2 | Description=Create a pwn.college backup
3 | 
4 | [Service]
5 | Type=simple
6 | ExecStart=dojo backup
7 | ExecCondition=:/bin/sh -c '. /data/config.env; [ "${WORKSPACE_NODE}" -eq 0 ]'
8 | 


--------------------------------------------------------------------------------
/etc/systemd/system/pwn.college.backup.timer:
--------------------------------------------------------------------------------
1 | [Unit]
2 | Description=Timer to run pwn.college local backup service
3 | 
4 | [Timer]
5 | OnCalendar=hourly
6 | 
7 | [Install]
8 | WantedBy=timers.target
9 | 


--------------------------------------------------------------------------------
/etc/systemd/system/pwn.college.cachewarmer.service:
--------------------------------------------------------------------------------
1 | [Unit]
2 | Description=Keep the pwn.college caches warm!
3 | 
4 | [Service]
5 | Type=simple
6 | ExecStart=warm_cache.sh
7 | ExecCondition=:/bin/sh -c '. /data/config.env; [ "${WORKSPACE_NODE}" -eq 0 ]'
8 | 


--------------------------------------------------------------------------------
/etc/systemd/system/pwn.college.cachewarmer.timer:
--------------------------------------------------------------------------------
1 | [Unit]
2 | Description=Timer to run pwn.college cachewarmer service
3 | 
4 | [Timer]
5 | OnCalendar=*-*-* *:*:00
6 | 
7 | [Install]
8 | WantedBy=timers.target
9 | 


--------------------------------------------------------------------------------
/etc/systemd/system/pwn.college.cloud.backup.service:
--------------------------------------------------------------------------------
1 | [Unit]
2 | Description=Upload a pwn.college backup to cloud (at this time just an S3 bucket).
3 | 
4 | [Service]
5 | Type=simple
6 | ExecStart=dojo cloud-backup
7 | ExecCondition=:/bin/sh -c '. /data/config.env; [ ! -z ${BACKUP_AES_KEY_FILE+x} ]'
8 | 


--------------------------------------------------------------------------------
/etc/systemd/system/pwn.college.cloud.backup.timer:
--------------------------------------------------------------------------------
1 | [Unit]
2 | Description=Timer to run pwn.college cloud backup service
3 | 
4 | [Timer]
5 | OnCalendar=daily
6 | 
7 | [Install]
8 | WantedBy=timers.target
9 | 


--------------------------------------------------------------------------------
/etc/systemd/system/pwn.college.imagepuller.service:
--------------------------------------------------------------------------------
1 | [Unit]
2 | Description=Pull custom container images!
3 | 
4 | [Service]
5 | Type=simple
6 | ExecStart=pull_images.sh
7 | ExecCondition=:/bin/sh -c '. /data/config.env; [ "${WORKSPACE_NODE}" -eq 0 ]'
8 | 


--------------------------------------------------------------------------------
/etc/systemd/system/pwn.college.imagepuller.timer:
--------------------------------------------------------------------------------
1 | [Unit]
2 | Description=Timer to run pwn.college imagepuller service
3 | 
4 | [Timer]
5 | OnCalendar=*-*-* *:*:00
6 | 
7 | [Install]
8 | WantedBy=timers.target
9 | 


--------------------------------------------------------------------------------
/etc/systemd/system/pwn.college.service:
--------------------------------------------------------------------------------
 1 | [Unit]
 2 | Description=pwn.college docker compose service
 3 | Requires=docker.service
 4 | After=docker.service
 5 | 
 6 | [Service]
 7 | Type=oneshot
 8 | RemainAfterExit=true
 9 | WorkingDirectory=/opt/pwn.college
10 | ExecStart=/usr/bin/dojo up
11 | ExecStop=/usr/bin/dojo compose down
12 | 
13 | [Install]
14 | WantedBy=multi-user.target
15 | 


--------------------------------------------------------------------------------
/grafana/datasource.yml:
--------------------------------------------------------------------------------
1 | apiVersion: 1
2 | 
3 | datasources:
4 |   - name: Prometheus
5 |     type: prometheus
6 |     access: proxy
7 |     url: http://prometheus:9090
8 |     isDefault: true
9 | 


--------------------------------------------------------------------------------
/homefs/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM python:3.12-slim
 2 | 
 3 | RUN apt-get update && \
 4 |     apt-get install -y \
 5 |         btrfs-progs && \
 6 |     rm -rf /var/lib/apt/lists/* && \
 7 |     pip install \
 8 |         flask \
 9 |         flask_sqlalchemy \
10 |         gunicorn \
11 |         requests
12 | 
13 | WORKDIR /opt/homefs
14 | COPY . .
15 | 
16 | EXPOSE 80
17 | CMD ["gunicorn", \
18 |      "homefs:create_app()", \
19 |      "--bind=unix:/run/docker/plugins/homefs.sock", \
20 |      "--bind=0.0.0.0:4201", \
21 |      "--workers=32", \
22 |      "--access-logfile=-", \
23 |      "--access-logformat", \
24 |      "%(h)s %(l)s %(u)s %(t)s \"%(r)s\" %(s)s %(b)s \"%(f)s\" \"%(a)s\" %(L)s", \
25 |      "--timeout=300"]
26 | 


--------------------------------------------------------------------------------
/homefs/homefs.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | from pathlib import Path
 3 | 
 4 | from flask import Flask
 5 | from werkzeug.routing import BaseConverter
 6 | 
 7 | from models import db
 8 | from btrfs_volume import check_volume_storage, BTRFSVolume
 9 | from volume_server import volume_server
10 | from volume_driver import volume_driver
11 | from utils import file_lock
12 | 
13 | 
14 | STORAGE_ROOT = Path(os.environ.get("STORAGE_ROOT", "/data"))
15 | 
16 | 
17 | class VolumeConverter(BaseConverter):
18 |     def to_python(self, value):
19 |         return BTRFSVolume(value)
20 | 
21 |     def to_url(self, value):
22 |         return value.name
23 | 
24 | 
25 | @file_lock("/run/homefs.lock")
26 | def create_app():
27 |     check_volume_storage()
28 | 
29 |     app = Flask(__name__)
30 | 
31 |     homefs_db_path= STORAGE_ROOT / "homefs.db"
32 |     app.config["SQLALCHEMY_DATABASE_URI"] = f"sqlite:///{homefs_db_path}"
33 | 
34 |     db.init_app(app)
35 | 
36 |     with app.app_context():
37 |         db.create_all()
38 | 
39 |     app.url_map.converters["volume"] = VolumeConverter
40 | 
41 |     app.register_blueprint(volume_driver, url_prefix="/")
42 |     app.register_blueprint(volume_server, url_prefix="/volume")
43 | 
44 |     return app
45 | 


--------------------------------------------------------------------------------
/homefs/models.py:
--------------------------------------------------------------------------------
 1 | from flask_sqlalchemy import SQLAlchemy
 2 | 
 3 | from btrfs_volume import BTRFSVolume
 4 | 
 5 | 
 6 | db = SQLAlchemy()
 7 | 
 8 | 
 9 | class ActiveVolumes(db.Model):
10 |     name = db.Column(db.String, primary_key=True)
11 |     host = db.Column(db.String)
12 |     created = db.Column(db.DateTime, server_default=db.func.now())
13 | 
14 | 
15 | class DockerVolumes(db.Model):
16 |     __tablename__ = "docker_volumes"
17 |     name = db.Column(db.String, primary_key=True)
18 |     created = db.Column(db.DateTime, server_default=db.func.now())
19 |     overlay = db.Column(db.String, default=None)
20 | 
21 |     @property
22 |     def btrfs(self):
23 |         return BTRFSVolume(self.name) if not self.overlay else BTRFSVolume(self.overlay)
24 | 
25 |     @property
26 |     def mountpoint(self):
27 |         return self.btrfs.active_path if not self.overlay else self.btrfs.overlays_path / self.name
28 | 


--------------------------------------------------------------------------------
/homefs/utils.py:
--------------------------------------------------------------------------------
 1 | import fcntl
 2 | import os
 3 | import time
 4 | from contextlib import contextmanager
 5 | 
 6 | 
 7 | @contextmanager
 8 | def file_lock(path, *, timeout=None):
 9 |     lock_fd = os.open(path, os.O_CREAT | os.O_RDWR)
10 |     try:
11 |         if timeout is None:
12 |             fcntl.flock(lock_fd, fcntl.LOCK_EX)
13 |         else:
14 |             start_time = time.time()
15 |             try:
16 |                 fcntl.flock(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
17 |             except BlockingIOError:
18 |                 if timeout >= 0 and time.time() - start_time > timeout:
19 |                     raise TimeoutError
20 |                 time.sleep(0.1)
21 |         yield
22 |     finally:
23 |         fcntl.flock(lock_fd, fcntl.LOCK_UN)
24 |         os.close(lock_fd)
25 | 


--------------------------------------------------------------------------------
/homefs/volume_driver.py:
--------------------------------------------------------------------------------
  1 | import functools
  2 | import inspect
  3 | import os
  4 | 
  5 | from flask import Blueprint, jsonify, request
  6 | from sqlalchemy.exc import IntegrityError
  7 | 
  8 | from models import DockerVolumes, db
  9 | 
 10 | 
 11 | STORAGE_HOST = os.environ.get("STORAGE_HOST", "localhost")
 12 | volume_driver = Blueprint("volume_driver", __name__)
 13 | 
 14 | 
 15 | @volume_driver.route("/Plugin.Activate", methods=["POST"])
 16 | def plugin_activate():
 17 |     return jsonify({"Implements": ["VolumeDriver"]})
 18 | 
 19 | 
 20 | def driver_route(method_name):
 21 |     def decorator(func):
 22 |         @volume_driver.route(f"/VolumeDriver.{method_name}", methods=["POST"])
 23 |         @functools.wraps(func)
 24 |         def wrapped():
 25 |             data = request.get_json(force=True)
 26 |             signature = inspect.signature(func)
 27 |             kwargs = {k.lower(): v for k, v in data.items() if k.lower() in signature.parameters}
 28 |             return func(**kwargs)
 29 |         return wrapped
 30 |     return decorator
 31 | 
 32 | 
 33 | @driver_route("Get")
 34 | def get(name):
 35 |     docker_volume = DockerVolumes.query.filter_by(name=name).first()
 36 |     if not docker_volume:
 37 |         return jsonify({"Err": f"Volume {name} not found"}), 404
 38 |     return jsonify({
 39 |         "Volume": {
 40 |             "Name": docker_volume.name,
 41 |             "Mountpoint": str(docker_volume.mountpoint),
 42 |             "Status": {}
 43 |         },
 44 |         "Err": "",
 45 |     })
 46 | 
 47 | 
 48 | @driver_route("Create")
 49 | def create_volume(name, opts=None):
 50 |     if opts is None:
 51 |         opts = {}
 52 |     docker_volume = DockerVolumes(name=name, overlay=opts.get("overlay"))
 53 |     try:
 54 |         db.session.add(docker_volume)
 55 |         db.session.commit()
 56 |     except IntegrityError:
 57 |         return jsonify({"Err": f"Volume {name} already exists"}), 409
 58 |     return jsonify({"Err": ""}), 200
 59 | 
 60 | 
 61 | @driver_route("Mount")
 62 | def mount_volume(name, id):
 63 |     docker_volume = DockerVolumes.query.filter_by(name=name).first()
 64 |     if not docker_volume:
 65 |         return jsonify({"Err": f"Volume {name} not found"}), 404
 66 | 
 67 |     if not docker_volume.overlay:
 68 |         docker_volume.btrfs.activate(STORAGE_HOST)
 69 | 
 70 |     elif not docker_volume.mountpoint.exists():
 71 |         snapshot_path = docker_volume.btrfs.fetch(STORAGE_HOST)
 72 |         docker_volume.btrfs.overlay(docker_volume.name, snapshot_path)
 73 | 
 74 |     return jsonify({"Mountpoint": str(docker_volume.mountpoint), "Err": ""})
 75 | 
 76 | 
 77 | @driver_route("Unmount")
 78 | def unmount_volume(name, id):
 79 |     docker_volume = DockerVolumes.query.filter_by(name=name).first()
 80 |     if not docker_volume:
 81 |         return jsonify({"Err": f"Volume {name} not found"}), 404
 82 | 
 83 |     return jsonify({"Err": ""})
 84 | 
 85 | 
 86 | @driver_route("Remove")
 87 | def remove_volume(name):
 88 |     docker_volume = DockerVolumes.query.filter_by(name=name).first()
 89 |     if not docker_volume:
 90 |         return jsonify({"Err": f"Volume {name} not found"}), 404
 91 | 
 92 |     if docker_volume.overlay:
 93 |         docker_volume.btrfs.remove_overlay(docker_volume.name)
 94 |     else:
 95 |         docker_volume.btrfs.snapshot()
 96 | 
 97 |     db.session.delete(docker_volume)
 98 |     db.session.commit()
 99 |     return jsonify({"Err": ""})
100 | 
101 | 
102 | @driver_route("Path")
103 | def volume_path(name):
104 |     docker_volume = DockerVolumes.query.filter_by(name=name).first()
105 |     if not docker_volume:
106 |         return jsonify({"Err": f"Volume {name} not found"}), 404
107 |     return jsonify({"Mountpoint": str(docker_volume.mountpoint), "Err": ""})
108 | 
109 | 
110 | @driver_route("List")
111 | def list_volumes():
112 |     return jsonify({
113 |         "Volumes": [
114 |             {"Name": docker_volume.name, "Mountpoint": str(docker_volume.mountpoint)}
115 |             for docker_volume in DockerVolumes.query.all()
116 |         ],
117 |         "Err": ""
118 |     })
119 | 
120 | 
121 | @driver_route("Capabilities")
122 | def volume_capabilities():
123 |     return jsonify({"Capabilities": {"Scope": "local"}})
124 | 


--------------------------------------------------------------------------------
/homefs/volume_server.py:
--------------------------------------------------------------------------------
 1 | from flask import Blueprint, Response, request
 2 | from sqlalchemy.exc import IntegrityError
 3 | 
 4 | from models import ActiveVolumes, db
 5 | 
 6 | 
 7 | volume_server = Blueprint("volume", __name__)
 8 | 
 9 | 
10 | @volume_server.route("/<volume:volume>", methods=["GET"])
11 | def get_volume(volume):
12 |     # If it active on this node, do not fetch it (infinite recursive loop)
13 |     if not volume.active:
14 |         active_volume = ActiveVolumes.query.filter_by(name=volume.name).first()
15 |         if active_volume:
16 |             volume.fetch(active_volume.host)
17 | 
18 |     snapshot_path = volume.snapshot()
19 |     if request.headers.get("If-None-Match") == snapshot_path.name:
20 |         return Response(status=304, headers={"ETag": snapshot_path.name})
21 | 
22 |     stream = volume.send(snapshot_path)
23 |     return Response(stream, mimetype="application/octet-stream", headers={"ETag": snapshot_path.name})
24 | 
25 | 
26 | @volume_server.route("/<volume:volume>", methods=["PUT"])
27 | def put_volume(volume):
28 |     try:
29 |         volume.receive(request.stream)
30 |     except RuntimeError as e:
31 |         return str(e), 400
32 |     return "Volume successfully received\n", 201
33 | 
34 | 
35 | @volume_server.route("/<volume:volume>/activate", methods=["POST"])
36 | def activate_volume(volume):
37 |     active_volume = ActiveVolumes.query.filter_by(name=volume.name).first()
38 |     if active_volume:
39 |         if active_volume.host != request.remote_addr:
40 |             return "Volume already active\n", 409
41 |         else:
42 |             return "Volume activated\n", 201
43 | 
44 |     active_volume = ActiveVolumes(name=volume.name, host=request.remote_addr)
45 |     try:
46 |         db.session.add(active_volume)
47 |         db.session.commit()
48 |     except IntegrityError:
49 |         # Someone else might have activated the volume in the meantime
50 |         # Error even if the remote host is the same (this shouldn't happen)
51 |         return "Volume already active\n", 409
52 | 
53 |     return "Volume activated\n", 201
54 | 


--------------------------------------------------------------------------------
/nginx-proxy/etc/nginx/proxy.conf:
--------------------------------------------------------------------------------
 1 | # HTTP 1.1 support
 2 | proxy_http_version 1.1;
 3 | proxy_set_header Host $http_host;
 4 | proxy_set_header Upgrade $http_upgrade;
 5 | proxy_set_header Connection $proxy_connection;
 6 | proxy_set_header X-Real-IP $remote_addr;
 7 | proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 8 | proxy_set_header X-Forwarded-Host $proxy_x_forwarded_host;
 9 | proxy_set_header X-Forwarded-Proto $proxy_x_forwarded_proto;
10 | proxy_set_header X-Forwarded-Ssl $proxy_x_forwarded_ssl;
11 | proxy_set_header X-Forwarded-Port $proxy_x_forwarded_port;
12 | proxy_set_header X-Original-URI $request_uri;
13 | 
14 | # Mitigate httpoxy attack (see README for details)
15 | proxy_set_header Proxy "";
16 | 
17 | proxy_read_timeout 300s;
18 | 


--------------------------------------------------------------------------------
/nginx-proxy/etc/nginx/vhost.d/default:
--------------------------------------------------------------------------------
 1 | ## Start of configuration add by letsencrypt container
 2 | location ^~ /.well-known/acme-challenge/ {
 3 |     auth_basic off;
 4 |     auth_request off;
 5 |     allow all;
 6 |     root /usr/share/nginx/html;
 7 |     try_files $uri =404;
 8 |     break;
 9 | }
10 | ## End of configuration add by letsencrypt container
11 | 
12 | location @forward {
13 |     set $redirect_uri "$upstream_http_redirect_uri";
14 |     set $redirect_auth "$upstream_http_redirect_auth";
15 | 
16 |     proxy_set_header X-Real-IP $remote_addr;
17 |     proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
18 |     proxy_set_header X-Forwarded-Proto $scheme;
19 |     proxy_set_header X-Forwarded-Host $host;
20 |     proxy_set_header X-Forwarded-Port $server_port;
21 |     proxy_set_header X-Forwarded-Prefix /sensai;
22 | 
23 |     proxy_set_header Authorization $redirect_auth;
24 | 
25 |     proxy_set_header Upgrade $http_upgrade;
26 |     proxy_set_header Connection $http_connection;
27 |     proxy_cache_bypass $http_upgrade;
28 | 
29 |     proxy_buffering off;
30 |     proxy_http_version 1.1;
31 |     proxy_pass $redirect_uri;
32 | 
33 |     proxy_ignore_headers X-Accel-Redirect;
34 | }
35 | 
36 | 


--------------------------------------------------------------------------------
/nginx-proxy/etc/nginx/vhost.d/default_location:
--------------------------------------------------------------------------------
 1 | location /internal/ {
 2 |     internal;
 3 |     set $redirect_uri "$upstream_http_redirect_uri";
 4 | 
 5 |     proxy_buffering off;
 6 |     proxy_http_version 1.1;
 7 |     proxy_pass $redirect_uri;
 8 | 
 9 |     proxy_ignore_headers X-Accel-Redirect;
10 | }
11 | 
12 | 


--------------------------------------------------------------------------------
/prometheus/prometheus.yml:
--------------------------------------------------------------------------------
 1 | global:
 2 |   scrape_interval: 15s
 3 | 
 4 | scrape_configs:
 5 |   - job_name: 'cadvisor'
 6 |     file_sd_configs:
 7 |       - files:
 8 |         - /etc/prometheus/targets/cadvisor.json
 9 | 
10 |   - job_name: 'node_exporter'
11 |     file_sd_configs:
12 |       - files:
13 |           - /etc/prometheus/targets/node_exporter.json
14 | 


--------------------------------------------------------------------------------
/sshd/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM alpine:3.20.3
 2 | 
 3 | RUN apk add --no-cache \
 4 |         python3 \
 5 |         py3-pip \
 6 |         openssh-server-pam \
 7 |         openssh-client \
 8 |         docker-cli \
 9 |         mysql-client
10 | 
11 | RUN pip3 install --break-system-packages requests==2.31.0 docker redis
12 | 
13 | RUN addgroup -g 995 docker && \
14 |     adduser -S hacker -G docker -s /bin/sh && \
15 |     mkdir -p /home/hacker/.docker && \
16 |     echo '{ "detachKeys": "ctrl-q,ctrl-q" }' > /home/hacker/.docker/config.json
17 | 
18 | RUN mkdir -p /run/sshd
19 | 
20 | WORKDIR /opt/sshd
21 | COPY . .
22 | RUN chmod 700 /opt/sshd/auth.py
23 | 
24 | EXPOSE 22
25 | 
26 | ENTRYPOINT ["/opt/sshd/start.sh"]
27 | 


--------------------------------------------------------------------------------
/sshd/auth.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | import sys
 4 | import pathlib
 5 | import os
 6 | import subprocess
 7 | 
 8 | # adamd: insanity to reload the environment varaibles from the docker compose
 9 | 
10 | global_env = "/etc/environment"
11 | if os.path.exists(global_env):
12 |     with open(global_env, "r") as f:
13 |         for line in f.readlines():
14 |             res = line.strip().split("=", maxsplit=1)
15 |             if res and len(res) == 2:
16 |                 key = res[0]
17 |                 value = res[1]
18 |                 os.environ[key] = value
19 | 
20 | 
21 | DB_HOST = os.environ.get('DB_HOST', "db")
22 | DB_NAME = os.environ.get('DB_NAME', "ctfd")
23 | DB_USER = os.environ.get('DB_USER', "ctfd")
24 | DB_PASS = os.environ.get('DB_PASS', "ctfd")
25 | 
26 | def error(msg):
27 |     print(msg, file=sys.stderr)
28 |     exit(1)
29 | 
30 | 
31 | def main():
32 |     enter_path = pathlib.Path(__file__).parent.resolve() / "enter.py"
33 | 
34 |     # dirty dirty hack
35 |     target_key = pathlib.Path(__file__).parent.resolve() / "pwn-college-mac-key"
36 |     subprocess.run(f"cp {os.environ.get('MAC_KEY_FILE', '/opt/pwn.college/data/mac-key')} {target_key} ; chown hacker:docker {target_key} ; chmod 600 {target_key}",
37 |                    shell=True,
38 |                    )
39 |     connect_arg = f"-h{DB_HOST}" if DB_HOST else ""
40 |     result = subprocess.run(["mysql", connect_arg, f"-p{DB_PASS}", f"-u{DB_USER}", f"-D{DB_NAME}", "-sNe", 'select value, user_id from ssh_keys;'], stdout=subprocess.PIPE)
41 |     if result.returncode != 0:
42 |         error(f"Error: db query exited with code '{result.returncode}'")
43 | 
44 |     for row in result.stdout.strip().split(b"\n"):
45 |         key, user_id = row.decode().split("\t")
46 |         print(f'command="{enter_path} user_{user_id}" {key}')
47 | 
48 | 
49 | if __name__ == "__main__":
50 |     main()
51 | 


--------------------------------------------------------------------------------
/sshd/enter.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | 
  3 | import json
  4 | import os
  5 | import pathlib
  6 | import shlex
  7 | import sys
  8 | import time
  9 | 
 10 | import docker
 11 | import redis
 12 | 
 13 | import mac_docker
 14 | 
 15 | 
 16 | WORKSPACE_NODES = {
 17 |     int(node_id): node_key
 18 |     for node_id, node_key in
 19 |     json.load(pathlib.Path("/var/workspace_nodes.json").open()).items()
 20 | }
 21 | 
 22 | r = redis.from_url(os.environ.get("REDIS_URL"))
 23 | 
 24 | def get_docker_client(user_id):
 25 |     image_name = r.get(f"flask_cache_user_{user_id}-running-image")
 26 |     node_id = list(WORKSPACE_NODES.keys())[user_id % len(WORKSPACE_NODES)] if WORKSPACE_NODES else None
 27 |     docker_host = f"tcp://192.168.42.{node_id + 1}:2375" if node_id is not None else "unix:///var/run/docker.sock"
 28 | 
 29 |     is_mac = False
 30 |     if image_name and b"mac:" in image_name:
 31 |         docker_client = mac_docker.MacDockerClient(key_filename="/opt/sshd/pwn-college-mac-key")
 32 |         is_mac = True
 33 |     else:
 34 |         docker_client = docker.DockerClient(base_url=docker_host, tls=False)
 35 |     return docker_host, docker_client, is_mac
 36 | 
 37 | 
 38 | def main():
 39 |     original_command = os.getenv("SSH_ORIGINAL_COMMAND")
 40 |     tty = os.getenv("SSH_TTY") is not None
 41 |     simple = bool(not tty or original_command)
 42 | 
 43 |     def print(*args, **kwargs):
 44 |         if simple:
 45 |             return
 46 |         kwargs.update(file=sys.stderr)
 47 |         return __builtins__.print(*args, **kwargs)
 48 | 
 49 |     if len(sys.argv) != 2:
 50 |         print(f"{sys.argv[0]} <container_name>")
 51 |         exit(1)
 52 |     container_name = sys.argv[1]
 53 |     user_id = int(container_name.split("_")[1])
 54 | 
 55 |     docker_host, docker_client, is_mac = get_docker_client(user_id)
 56 | 
 57 |     try:
 58 |         container = docker_client.containers.get(container_name)
 59 |     except docker.errors.NotFound:
 60 |         print("No active challenge session; start a challenge!")
 61 |         exit(1)
 62 | 
 63 |     attempts = 0
 64 |     while attempts < 30:
 65 |         if attempts != 0:
 66 |             docker_host, docker_client, is_mac = get_docker_client(user_id)
 67 |         try:
 68 |             container = docker_client.containers.get(container_name)
 69 |             status = container.status
 70 |         except docker.errors.NotFound:
 71 |             status = "uninitialized"
 72 | 
 73 |         if status == "running":
 74 |             try:
 75 |                 container.get_archive("/run/dojo/var/ready")
 76 |             except docker.errors.NotFound:
 77 |                 status = "initializing"
 78 | 
 79 |         if status != "running":
 80 |             attempts += 1
 81 |             print("\033c", end="")
 82 |             print("\r", " " * 80, f"\rConnecting -- instance status: {status}", end="")
 83 |             time.sleep(1)
 84 |             continue
 85 | 
 86 |         attempts = 0
 87 |         print("\r", " " * 80, "\rConnected!")
 88 | 
 89 |         if not os.fork():
 90 |             ssh_entrypoint = "/run/dojo/bin/ssh-entrypoint"
 91 |             if is_mac:
 92 |                 cmd = f"/bin/bash -c {shlex.quote(original_command)}" if original_command  else "zsh -i"
 93 |                 container.execve_shell(cmd, user="1000", use_tty=tty)
 94 |             else:
 95 |                 command = [ssh_entrypoint, "-c", original_command] if original_command else [ssh_entrypoint]
 96 |                 os.execve(
 97 |                     "/usr/bin/docker",
 98 |                     [
 99 |                         "docker",
100 |                         "exec",
101 |                         "-it" if tty else "-i",
102 |                         "--user=1000",
103 |                         "--workdir=/home/hacker",
104 |                         container_name,
105 |                         *command,
106 |                     ],
107 |                     {
108 |                         "HOME": os.environ["HOME"],
109 |                         "DOCKER_HOST": docker_host,
110 |                     },
111 |                 )
112 | 
113 |         else:
114 |             _, status = os.wait()
115 |             if simple or status == 0:
116 |                 break
117 |             print()
118 |             print("\r", " " * 80, "\rConnecting", end="")
119 |             time.sleep(0.5)
120 |     else:
121 |         print("\r", " " * 80, "\rError: failed to connect!")
122 | 
123 | 
124 | if __name__ == "__main__":
125 |     main()
126 | 


--------------------------------------------------------------------------------
/sshd/sshd_config:
--------------------------------------------------------------------------------
 1 | ChallengeResponseAuthentication no
 2 | PasswordAuthentication no
 3 | UsePAM yes
 4 | 
 5 | Subsystem sftp    /run/dojo/libexec/sftp-server
 6 | 
 7 | Match User hacker
 8 |       AuthorizedKeysCommand /opt/sshd/auth.py
 9 |       AuthorizedKeysCommandUser root
10 |       X11Forwarding no
11 |       AllowTcpForwarding no
12 | 


--------------------------------------------------------------------------------
/sshd/start.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | 
3 | # adamd: hack here so that the auth.py command can get the environment variables we set in the docker compose
4 | printenv | grep -v "no_proxy" >> /etc/environment
5 | 
6 | /usr/sbin/sshd.pam -D -e -f /opt/sshd/sshd_config
7 | 


--------------------------------------------------------------------------------
/test/dojos/fake_blue.yml:
--------------------------------------------------------------------------------
 1 | id: software-exploitation
 2 | type: topic
 3 | modules:
 4 |   - id: test
 5 |     challenges:
 6 |       - id: test
 7 |         import:
 8 |           dojo: example
 9 |           module: world
10 |           challenge: earth
11 |       
12 | 


--------------------------------------------------------------------------------
/test/dojos/fake_green.yml:
--------------------------------------------------------------------------------
 1 | id: system-security
 2 | type: topic
 3 | modules:
 4 |   - id: test
 5 |     challenges:
 6 |       - id: test
 7 |         import:
 8 |           dojo: example
 9 |           module: world
10 |           challenge: venus
11 |       
12 | 


--------------------------------------------------------------------------------
/test/dojos/fake_orange.yml:
--------------------------------------------------------------------------------
 1 | id: intro-to-cybersecurity
 2 | type: topic
 3 | modules:
 4 |   - id: test
 5 |     challenges:
 6 |       - id: test
 7 |         import:
 8 |           dojo: example
 9 |           module: hello
10 |           challenge: apple
11 |       
12 | 


--------------------------------------------------------------------------------
/test/dojos/fake_yellow.yml:
--------------------------------------------------------------------------------
 1 | id: program-security
 2 | type: topic
 3 | modules:
 4 |   - id: test
 5 |     challenges:
 6 |       - id: test
 7 |         import:
 8 |           dojo: example
 9 |           module: hello
10 |           challenge: banana
11 |       
12 | 


--------------------------------------------------------------------------------
/test/dojos/forbidden_import.yml:
--------------------------------------------------------------------------------
 1 | id: forbidden-import
 2 | type: public
 3 | modules:
 4 |   - id: test
 5 |     challenges:
 6 |       - id: test
 7 |         import:
 8 |           dojo: no-import-challenge
 9 |           module: test
10 |           challenge: test
11 |       
12 | 


--------------------------------------------------------------------------------
/test/dojos/import_override.yml:
--------------------------------------------------------------------------------
 1 | id: intro-to-cybersecurity
 2 | type: topic
 3 | modules:
 4 |   - id: test
 5 |     challenges:
 6 |       - id: test
 7 |         import:
 8 |           dojo: example
 9 |           module: hello
10 |           challenge: apple
11 | files:
12 |   - type: text
13 |     path: test/test/boom
14 |     content: |
15 |       #!/opt/pwn.college/bash
16 |       cat /flag
17 | 


--------------------------------------------------------------------------------
/test/dojos/lfs_dojo.yml:
--------------------------------------------------------------------------------
 1 | id: lfs
 2 | type: public
 3 | modules:
 4 |   - id: test
 5 |     challenges:
 6 |       - id: test
 7 | files:
 8 |   - type: download
 9 |     url: "https://www.dropbox.com/scl/fi/deyhfwioo3d824ext4k42/dojo.txt?rlkey=h1wmm4oe9hq67ooan9oh2r36j&dl=1"
10 |     path: "test/test/dojo.txt"
11 | 


--------------------------------------------------------------------------------
/test/dojos/no_import_challenge.yml:
--------------------------------------------------------------------------------
 1 | id: no-import-challenge
 2 | type: public
 3 | modules:
 4 |   - id: test
 5 |     challenges:
 6 |       - id: test
 7 |         importable: false
 8 |         import:
 9 |           dojo: example
10 |           module: world
11 |           challenge: earth
12 |       
13 | 


--------------------------------------------------------------------------------
/test/dojos/no_practice_challenge.yml:
--------------------------------------------------------------------------------
 1 | id: no-practice-challenge
 2 | type: public
 3 | modules:
 4 |   - id: test
 5 |     challenges:
 6 |       - id: test
 7 |         allow_privileged: False
 8 |         import:
 9 |           dojo: example
10 |           module: world
11 |           challenge: earth
12 |       
13 | 


--------------------------------------------------------------------------------
/test/dojos/no_practice_dojo.yml:
--------------------------------------------------------------------------------
 1 | id: no-practice-dojo
 2 | type: public
 3 | allow_privileged: False
 4 | modules:
 5 |   - id: test
 6 |     challenges:
 7 |       - id: test
 8 |         import:
 9 |           dojo: example
10 |           module: world
11 |           challenge: earth
12 |       
13 | 


--------------------------------------------------------------------------------
/test/dojos/progression_locked_dojo.yml:
--------------------------------------------------------------------------------
 1 | id: progression-locked-dojo
 2 | type: public
 3 | modules:
 4 |   - id: progression-locked-module
 5 |     challenges:
 6 |       - id: unlocked-challenge
 7 |         progression_locked: true
 8 |         import:
 9 |           dojo: example
10 |           module: world
11 |           challenge: earth
12 |       - id: locked-challenge
13 |         progression_locked: true
14 |         import:
15 |           dojo: example
16 |           module: world
17 |           challenge: mars
18 | 


--------------------------------------------------------------------------------
/test/dojos/searchable_dojo.yml:
--------------------------------------------------------------------------------
 1 | id: search-test-dojo
 2 | name: Searchable Dojo
 3 | description: This dojo contains search test content.
 4 | modules:
 5 |   - id: hello-module
 6 |     name: Hello Module
 7 |     description: This module helps search testing.
 8 |     challenges:
 9 |       - id: apple-challenge
10 |         name: Apple Challenge
11 |         description: This challenge is about apples.
12 |         import:
13 |           dojo: example
14 |           module: hello
15 |           challenge: apple
16 | 


--------------------------------------------------------------------------------
/test/dojos/simple_award_dojo.yml:
--------------------------------------------------------------------------------
1 | id: simple-award
2 | type: public
3 | award:
4 |   emoji: 🧪
5 | modules:
6 |   - import:
7 |       dojo: example
8 |       module: hello
9 | 


--------------------------------------------------------------------------------
/test/dojos/surveys_dojo.yml:
--------------------------------------------------------------------------------
 1 | id: surveys-dojo
 2 | type: public
 3 | survey:
 4 |   prompt: Dojo-level prompt
 5 |   type: multiplechoice
 6 |   options:
 7 |     - Option 1
 8 |     - Option 2
 9 |     - Option 3
10 | modules:
11 |   - id: surveys-module-1
12 |     survey:
13 |       prompt: Module-level prompt
14 |       type: thumb
15 |     challenges:
16 |       - id: module-level
17 |         import:
18 |           dojo: example
19 |           module: world
20 |           challenge: earth
21 |       - id: challenge-level
22 |         import:
23 |           dojo: example
24 |           module: world
25 |           challenge: mars
26 |         survey:
27 |           prompt: Challenge-level prompt
28 |           type: freeform
29 |   - id: surveys-module-2
30 |     challenges:
31 |       - id: dojo-level
32 |         import:
33 |           dojo: example
34 |           module: world
35 |           challenge: venus
36 | 


--------------------------------------------------------------------------------
/test/dojos/transfer_dst.yml:
--------------------------------------------------------------------------------
 1 | id: dst-dojo
 2 | type: topic
 3 | modules:
 4 |   - id: dst-module
 5 |     challenges:
 6 |       - id: dst-challenge
 7 |         transfer:
 8 |           dojo: src-dojo
 9 |           module: src-module
10 |           challenge: src-challenge
11 | files:
12 |   - type: text
13 |     path: dst-module/dst-challenge/dst
14 |     content: |
15 |       #!/opt/pwn.college/bash
16 |       cat /flag
17 | 


--------------------------------------------------------------------------------
/test/dojos/transfer_src.yml:
--------------------------------------------------------------------------------
 1 | id: src-dojo
 2 | type: topic
 3 | modules:
 4 |   - id: src-module
 5 |     challenges:
 6 |       - id: src-challenge
 7 | files:
 8 |   - type: text
 9 |     path: src-module/src-challenge/src
10 |     content: |
11 |       #!/opt/pwn.college/bash
12 |       cat /flag
13 | 


--------------------------------------------------------------------------------
/test/local-tester.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash -ex
 2 | 
 3 | cd $(dirname "${BASH_SOURCE[0]}")/..
 4 | 
 5 | function usage {
 6 | 	set +x
 7 | 	echo "Usage: $0 [-r DB_BACKUP ] [ -c DOJO_CONTAINER ] [ -D DOCKER_DIR ] [ -T ]"
 8 | 	echo ""
 9 | 	echo "	-r	full path to db backup to restore"
10 | 	echo "	-c	the name of the dojo container (default: dojo-test)"
11 | 	echo "	-D	specify a directory for /data/docker (to avoid rebuilds)"
12 | 	echo "	-T	don't run tests"
13 | 	exit
14 | }
15 | 
16 | WORKDIR=$(mktemp -d /tmp/dojo-test-XXXXXX)
17 | 
18 | VOLUME_ARGS=("-v" "$PWD:/opt/pwn.college" "-v" "$WORKDIR:/data:shared")
19 | ENV_ARGS=( )
20 | DB_RESTORE=""
21 | DOJO_CONTAINER=dojo-test
22 | TEST=yes
23 | DOCKER_DIR=""
24 | while getopts "r:c:he:TD:" OPT
25 | do
26 | 	case $OPT in
27 | 		r) DB_RESTORE="$OPTARG" ;;
28 | 		c) DOJO_CONTAINER="$OPTARG" ;;
29 | 		T) TEST=no ;;
30 | 		D) DOCKER_DIR="$OPTARG" ;;
31 | 		e) ENV_ARGS+=("-e" "$OPTARG") ;;
32 | 		h) usage ;;
33 | 		?)
34 | 			OPTIND=$(($OPTIND-1))
35 | 			break
36 | 			;;
37 | 	esac
38 | done
39 | shift $((OPTIND-1))
40 | 
41 | export DOJO_CONTAINER
42 | docker kill "$DOJO_CONTAINER" 2>/dev/null || echo "No $DOJO_CONTAINER container to kill."
43 | docker rm "$DOJO_CONTAINER" 2>/dev/null || echo "No $DOJO_CONTAINER container to remove."
44 | while docker ps -a | grep "$DOJO_CONTAINER"; do sleep 1; done
45 | 
46 | # freaking bad unmount
47 | sleep 1
48 | mount | grep /tmp/dojo-test- | sed -e "s/.* on //" | sed -e "s/ .*//" | tac | while read ENTRY
49 | do
50 | 	sudo umount "$ENTRY"
51 | done
52 | 
53 | if [ -n "$DOCKER_DIR" ]
54 | then
55 | 	VOLUME_ARGS+=( "-v" "$DOCKER_DIR:/data/docker" )
56 | 	sudo rm -rf $DOCKER_DIR/{containers,volumes}
57 | fi
58 | 
59 | docker run --rm --privileged -d "${VOLUME_ARGS[@]}" "${ENV_ARGS[@]}" -p 2222:22 -p 80:80 -p 443:443 --name "$DOJO_CONTAINER" pwncollege/dojo || exit 1
60 | 
61 | # fix the insane routing thing
62 | read -a GW <<<$(ip route show default)
63 | read -a NS <<<$(docker exec "$DOJO_CONTAINER" cat /etc/resolv.conf | grep nameserver)
64 | docker exec "$DOJO_CONTAINER" ip route add "${GW[2]}" via 172.17.0.1
65 | docker exec "$DOJO_CONTAINER" ip route add "${NS[1]}" via 172.17.0.1 || echo "Failed to add nameserver route"
66 | 
67 | docker exec "$DOJO_CONTAINER" dojo wait
68 | if [ -n "$DB_RESTORE" ]
69 | then
70 | 	BASENAME=$(basename $DB_RESTORE)
71 | 	docker exec "$DOJO_CONTAINER" mkdir -p /data/backups/
72 | 	[ -f "$DB_RESTORE" ] && docker cp "$DB_RESTORE" "$DOJO_CONTAINER":/data/backups/"$BASENAME"
73 | 	docker exec "$DOJO_CONTAINER" dojo restore "$BASENAME"
74 | fi
75 | 
76 | until curl -Ls localhost.pwn.college | grep -q pwn; do sleep 1; done
77 | 
78 | docker exec "$DOJO_CONTAINER" docker pull pwncollege/challenge-simple
79 | docker exec "$DOJO_CONTAINER" docker tag pwncollege/challenge-simple pwncollege/challenge-legacy
80 | 
81 | [ "$TEST" == "yes" ] && MOZ_HEADLESS=1 pytest -v test/test_running.py test/test_welcome.py
82 | 


--------------------------------------------------------------------------------
/test/utils.py:
--------------------------------------------------------------------------------
 1 | import subprocess
 2 | import time
 3 | import requests
 4 | import pathlib
 5 | import shutil
 6 | import re
 7 | import os
 8 | 
 9 | DOJO_URL = os.getenv("DOJO_URL", "http://localhost.pwn.college")
10 | DOJO_CONTAINER = os.getenv("DOJO_CONTAINER", "dojo-test")
11 | TEST_DOJOS_LOCATION = pathlib.Path(__file__).parent / "dojos"
12 | 
13 | 
14 | def parse_csrf_token(text):
15 |     match = re.search("'csrfNonce': \"(\\w+)\"", text)
16 |     assert match, "Failed to find CSRF token"
17 |     return match.group(1)
18 | 
19 | 
20 | def login(name, password, *, success=True, register=False, email=None):
21 |     session = requests.Session()
22 |     endpoint = "login" if not register else "register"
23 |     nonce = parse_csrf_token(session.get(f"{DOJO_URL}/{endpoint}").text)
24 |     data = { "name": name, "password": password, "nonce": nonce }
25 |     if register:
26 |         data["email"] = email or f"{name}@example.com"
27 |     while True:
28 |         response = session.post(f"{DOJO_URL}/{endpoint}", data=data, allow_redirects=False)
29 |         if response.status_code == 429:
30 |             time.sleep(1)
31 |             continue
32 |         break
33 |     if not success:
34 |         assert response.status_code == 200, f"Expected {endpoint} failure (status code 200), but got {response.status_code}"
35 |         return session
36 |     assert response.status_code == 302, f"Expected {endpoint} success (status code 302), but got {response.status_code}"
37 |     session.headers["CSRF-Token"] = parse_csrf_token(session.get(f"{DOJO_URL}/").text)
38 |     return session
39 | 
40 | 
41 | def make_dojo_official(dojo_rid, admin_session):
42 |     response = admin_session.post(f"{DOJO_URL}/pwncollege_api/v1/dojos/{dojo_rid}/promote", json={})
43 |     assert response.status_code == 200, f"Expected status code 200, but got {response.status_code} - {response.json()}"
44 | 
45 | 
46 | def create_dojo(repository, *, session):
47 |     test_public_key = f"public/{repository}"
48 |     test_private_key = f"private/{repository}"
49 |     create_dojo_json = { "repository": repository, "public_key": test_public_key, "private_key": test_private_key }
50 |     response = session.post(f"{DOJO_URL}/pwncollege_api/v1/dojos/create", json=create_dojo_json)
51 |     assert response.status_code == 200, f"Expected status code 200, but got {response.status_code} - {response.json()}"
52 |     dojo_reference_id = response.json()["dojo"]
53 |     return dojo_reference_id
54 | 
55 | 
56 | def create_dojo_yml(spec, *, session):
57 |     response = session.post(f"{DOJO_URL}/pwncollege_api/v1/dojos/create", json={"spec": spec})
58 |     assert response.status_code == 200, f"Expected status code 200, but got {response.status_code} - {response.json()}"
59 |     dojo_reference_id = response.json()["dojo"]
60 |     return dojo_reference_id
61 | 
62 | 
63 | def dojo_run(*args, **kwargs):
64 |     kwargs.update(stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
65 |     return subprocess.run(
66 |         [shutil.which("docker"), "exec", "-i", DOJO_CONTAINER, "dojo", *args],
67 |         check=kwargs.pop("check", True), **kwargs
68 |     )
69 | 
70 | def workspace_run(cmd, *, user, root=False, **kwargs):
71 |     args = [ "enter" ]
72 |     if root:
73 |         args += [ "-s" ]
74 |     args += [ user ]
75 |     return dojo_run(*args, input=cmd, check=True, **kwargs)
76 | 


--------------------------------------------------------------------------------
/user_firewall.allowed:
--------------------------------------------------------------------------------
1 | example.com
2 | public-lumina.hex-rays.com
3 | msdl.microsoft.com
4 | 


--------------------------------------------------------------------------------
/watchdog/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM python:3.12-slim
 2 | 
 3 | RUN apt-get update && \
 4 |     apt-get install -y \
 5 |         cron && \
 6 |     rm -rf /var/lib/apt/lists/* && \
 7 |     pip install \
 8 |         docker
 9 | 
10 | COPY docker_remove_containers.py /usr/local/bin/docker_remove_containers
11 | COPY docker_prune_images.py /usr/local/bin/docker_prune_images
12 | 
13 | COPY <<'EOF' /etc/cron.d/watchdog-cron
14 | */5 * * * * /usr/local/bin/docker_remove_containers >> /proc/1/fd/1 2>> /proc/1/fd/2
15 | 0 9 * * * /usr/local/bin/docker_prune_images >> /proc/1/fd/1 2>> /proc/1/fd/2
16 | EOF
17 | 
18 | RUN crontab /etc/cron.d/watchdog-cron
19 | 
20 | CMD ["cron", "-f"]
21 | 


--------------------------------------------------------------------------------
/watchdog/docker_prune_images.py:
--------------------------------------------------------------------------------
 1 | #!/usr/local/bin/python3
 2 | 
 3 | import json
 4 | import logging
 5 | import os
 6 | from concurrent.futures import ThreadPoolExecutor
 7 | 
 8 | import docker
 9 | 
10 | logging.basicConfig(level=logging.INFO, format=f"%(asctime)s [{os.path.basename(__file__)}] [%(levelname)s] %(message)s")
11 | 
12 | logging.info("Starting")
13 | 
14 | workspace_nodes = json.load(open("/var/workspace_nodes.json"))
15 | workspace_node_ips = [f"192.168.42.{int(node_id) + 1}" for node_id in workspace_nodes]
16 | 
17 | def prune_images(docker_client_ip):
18 |     docker_client = docker.DockerClient(base_url=f"tcp://{docker_client_ip}:2375", timeout=3600)
19 |     logging.info(f"Pruning docker images on {docker_client.api.base_url}")
20 |     docker_client.images.prune()
21 |     logging.info(f"Prune docker images complete on {docker_client.api.base_url}")
22 | 
23 | with ThreadPoolExecutor() as executor:
24 |     logging.info("Pruning images")
25 |     list(executor.map(prune_images, workspace_node_ips))
26 |     logging.info("Pruned images")
27 | 
28 | logging.info("Finished")
29 | 


--------------------------------------------------------------------------------
/watchdog/docker_remove_containers.py:
--------------------------------------------------------------------------------
 1 | #!/usr/local/bin/python3
 2 | 
 3 | import json
 4 | import logging
 5 | import os
 6 | import re
 7 | from concurrent.futures import ThreadPoolExecutor
 8 | from datetime import datetime, timedelta, timezone
 9 | 
10 | import docker
11 | 
12 | OLD_CONTAINER_AGE = timedelta(hours=6)
13 | 
14 | GiB = 1024 ** 3
15 | LARGE_CONTAINER_SIZE = 16 * GiB
16 | 
17 | logging.basicConfig(level=logging.INFO, format=f"%(asctime)s [{os.path.basename(__file__)}] [%(levelname)s] %(message)s")
18 | 
19 | logging.info("Starting")
20 | 
21 | workspace_nodes = json.load(open("/var/workspace_nodes.json"))
22 | workspace_node_ips = [f"192.168.42.{int(node_id) + 1}" for node_id in workspace_nodes]
23 | 
24 | now = datetime.now(timezone.utc)
25 | 
26 | def human_size(n):
27 |     for unit in ['B','KiB','MiB','GiB','TiB']:
28 |         if abs(n) < 1024.0:
29 |             return f"{n:.1f}{unit}"
30 |         n /= 1024.0
31 |     return f"{n:.1f}PiB"
32 | 
33 | def remove_old_containers(docker_client_ip):
34 |     docker_client = docker.DockerClient(base_url=f"tcp://{docker_client_ip}:2375")
35 | 
36 |     logging.info(f"Removing docker containers on {docker_client.api.base_url}")
37 | 
38 |     containers = docker_client.containers.list(filters={"label": "dojo.user_id"}, ignore_removed=True)
39 | 
40 |     container_age = lambda container: now - datetime.fromisoformat(re.sub(r"(\.\d{0,6})\d*Z$", r"\1+00:00", container.attrs["Created"]))
41 |     old_containers = [container for container in containers if container_age(container) > OLD_CONTAINER_AGE]
42 |     for container in reversed(sorted(old_containers, key=container_age)):
43 |         user_id = container.labels["dojo.user_id"]
44 |         logging.info(f"Removing old docker container {container.id} (user {user_id}) on {docker_client.api.base_url}: {container_age(container).total_seconds() // 3600:.0f} hours")
45 |         container.remove(force=True)
46 | 
47 |     container_sizes = {
48 |         container["Id"]: container.get("SizeRw", 0)
49 |         for container in docker_client.df()["Containers"]
50 |     }
51 |     container_size = lambda container: container_sizes.get(container.id, 0)
52 |     large_containers = [container for container in containers if container_size(container) > LARGE_CONTAINER_SIZE]
53 |     for container in reversed(sorted(large_containers, key=container_size)):
54 |         user_id = container.labels["dojo.user_id"]
55 |         logging.info(f"Removing large docker container {container.id} (user {user_id}) on {docker_client.api.base_url}: {human_size(container_size(container))}")
56 |         container.remove(force=True)
57 | 
58 |     logging.info(f"Removed docker containers on {docker_client.api.base_url}")
59 | 
60 | with ThreadPoolExecutor() as executor:
61 |     logging.info("Removing docker containers")
62 |     list(executor.map(remove_old_containers, workspace_node_ips))
63 |     logging.info("Removed docker containers")
64 | 
65 | logging.info("Finished")
66 | 


--------------------------------------------------------------------------------
/workspace/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM alpine
 2 | 
 3 | RUN apk add --no-cache nix
 4 | 
 5 | RUN cat >> /etc/nix/nix.conf <<EOF
 6 | experimental-features = nix-command flakes
 7 | substituters = https://cache.nixos.org/
 8 | EOF
 9 | 
10 | COPY --chmod=755 <<'EOF' /docker-entrypoint.sh
11 | #!/bin/sh -e
12 | 
13 | TIMESTAMP=$(date +%Y%m%d%H%M%S)
14 | NIX_PROFILES_DIR=/nix/var/nix/profiles
15 | NIX_PROFILE=${NIX_PROFILES_DIR}/dojo-workspace-${TIMESTAMP}
16 | NIX_FLAKE_LOCK_FILE=/nix/var/nix/dojo-workspace-flake.lock
17 | 
18 | nix build ".#${DOJO_WORKSPACE:-default}" \
19 |     --out-link "$NIX_PROFILE" \
20 |     --reference-lock-file "$NIX_FLAKE_LOCK_FILE" \
21 |     --output-lock-file "$NIX_FLAKE_LOCK_FILE" \
22 |     --print-build-logs
23 | 
24 | SUID_FILE="$NIX_PROFILE/suid"
25 | if [ -e "$SUID_FILE" ]; then
26 |     while IFS= read -r path; do
27 |         if [ -e "$path" ]; then
28 |             echo "Setting SUID bit on $path"
29 |             chmod u+s "$path"
30 |         else
31 |             echo "Warning: file not found: $path" >&2
32 |         fi
33 |     done < "$SUID_FILE"
34 | else
35 |     echo "Warning: SUID file not found: $SUID_FILE" >&2
36 | fi
37 | 
38 | ln -sfn "$NIX_PROFILE" "${NIX_PROFILES_DIR}/dojo-workspace"
39 | echo "Updated profile to $NIX_PROFILE"
40 | 
41 | echo "Removing old profiles..."
42 | find "$NIX_PROFILES_DIR" -maxdepth 1 -name 'dojo-workspace-*' -type l -mmin +600 -print -exec rm -f {} +
43 | echo "Removed old profiles"
44 | 
45 | if  [ "$NIX_GARBAGE_COLLECT" = "true" ]; then
46 |     echo "Garbage collecting..."
47 |     nix-collect-garbage -d
48 |     echo "Garbage collected"
49 | fi
50 | EOF
51 | 
52 | WORKDIR /workspace
53 | COPY . .
54 | 
55 | ENTRYPOINT ["/docker-entrypoint.sh"]
56 | 


--------------------------------------------------------------------------------
/workspace/additional/additional.nix:
--------------------------------------------------------------------------------
 1 | { pkgs }:
 2 | 
 3 | let
 4 |   ghidra = import ./ghidra.nix { inherit pkgs; };
 5 |   burpsuite = import ./burpsuite.nix { inherit pkgs; };
 6 |   bata24-gef = import ./bata24-gef.nix { inherit pkgs; };
 7 | 
 8 |   pythonPackages = ps: with ps; [
 9 |     angr
10 |     asteval
11 |     flask
12 |     ipython
13 |     jupyter
14 |     psutil
15 |     pwntools
16 |     pycryptodome
17 |     pyroute2
18 |     r2pipe
19 |     requests
20 |     ropper
21 |     scapy
22 |     selenium
23 |   ];
24 | 
25 |   pythonEnv = pkgs.python3.withPackages pythonPackages;
26 | 
27 |   tools = with pkgs; {
28 |     build = [ gcc gnumake cmake qemu ];
29 | 
30 |     compression = [ zip unzip gzip gnutar ];
31 | 
32 |     system = [ htop rsync openssh nftables ];
33 | 
34 |     editors = [ vim neovim emacs nano gedit ];
35 | 
36 |     terminal = [ tmux screen ];
37 | 
38 |     network = [ netcat-openbsd tcpdump wireshark termshark nmap burpsuite ];
39 | 
40 |     debugging = [ strace ltrace gdb pwndbg gef bata24-gef ];
41 | 
42 |     reversing = [ file ghidra ida-free radare2 cutter angr-management binaryninja-free ];
43 | 
44 |     web = [ firefox geckodriver ];
45 | 
46 |     exploitation = [ aflplusplus rappel ropgadget sage ];
47 |   };
48 | 
49 | in
50 | {
51 |   packages = with pkgs;
52 |     [ (lib.hiPrio pythonEnv) ]
53 |     ++ tools.build
54 |     ++ tools.compression
55 |     ++ tools.system
56 |     ++ tools.editors
57 |     ++ tools.terminal
58 |     ++ tools.network
59 |     ++ tools.debugging
60 |     ++ tools.reversing
61 |     ++ tools.web
62 |     ++ tools.exploitation;
63 | }
64 | 


--------------------------------------------------------------------------------
/workspace/additional/bata24-gef.nix:
--------------------------------------------------------------------------------
 1 | { pkgs
 2 | , gdb ? pkgs.gdb
 3 | , python3 ? pkgs.python3
 4 | }:
 5 | 
 6 | let
 7 |   lib = pkgs.lib;
 8 |   pythonPath =
 9 |     with python3.pkgs;
10 |     makePythonPath [
11 |       keystone-engine
12 |       unicorn
13 |       capstone
14 |       ropper
15 |   ];
16 | in
17 | python3.pkgs.buildPythonPackage rec {
18 |   pname = "bata24-gef";
19 |   version = "unstable-2025-05-28";
20 | 
21 |   src = pkgs.fetchFromGitHub {
22 |     owner = "bata24";
23 |     repo = "gef";
24 |     rev = "4d7dc1d9a5a407aea3935622150aeea1fcf355dc";
25 |     sha256 = "sha256-xlTIQ0VbktdYHT4JRK6HzoKKT7WzKqqPS0aTbpvBMV0=";
26 |   };
27 | 
28 |   format = "other";
29 | 
30 |   nativeBuildInputs = [ pkgs.makeWrapper ];
31 | 
32 |   installPhase = ''
33 |     mkdir -p $out/share/bata24-gef
34 |     cp gef.py $out/share/bata24-gef
35 |     makeWrapper ${gdb}/bin/gdb $out/bin/bata24-gef \
36 |       --add-flags "-q -x $out/share/bata24-gef/gef.py" \
37 |       --set NIX_PYTHONPATH ${pythonPath} \
38 |       --prefix PATH : ${
39 |         lib.makeBinPath [
40 |           pkgs.gdb
41 |           python3
42 |           pkgs.bintools-unwrapped
43 |           pkgs.file
44 |           pkgs.ps
45 |         ]
46 |       }
47 |   '';
48 | 
49 |   meta = with lib; {
50 |     description = "GDB Enhanced Features fork by bata24";
51 |     mainProgram = "bata24-gef";
52 |     platforms = platforms.all;
53 |     homepage = "https://github.com/bata24/gef";
54 |     license = licenses.mit;
55 |     maintainers = with maintainers; [ ];
56 |   };
57 | }
58 | 


--------------------------------------------------------------------------------
/workspace/additional/burpsuite.nix:
--------------------------------------------------------------------------------
 1 | { pkgs }:
 2 | 
 3 | # burpsuite is packaged in a "buildFHSEnv" environment, which will not work in a container due to attempting to mount, but works fine without
 4 | 
 5 | let
 6 |   inherit (pkgs.burpsuite) pname version meta;
 7 | 
 8 |   description = "An integrated platform for performing security testing of web applications";
 9 | 
10 |   # avoid burpsuite dumping ~500MB of data into the home directory
11 |   extraFlags = "--disable-auto-update --data-dir=\\\${TMPDIR:-/tmp}/.BurpSuite";
12 | 
13 | in pkgs.stdenv.mkDerivation {
14 |   inherit pname version meta description;
15 | 
16 |   src = pkgs.burpsuite;
17 | 
18 |   buildInputs = [ pkgs.makeWrapper ];
19 | 
20 |   installPhase = ''
21 |       runHook preInstall
22 | 
23 |       initPath="$(sed -nE 's/.*--symlink ([^ ]*) \/init.*/\1/p' "$src/bin/burpsuite")"
24 |       if [ -z "$initPath" ]; then
25 |         echo "Error: Could not extract init script from burpsuite launcher" >&2
26 |         exit 1
27 |       fi
28 | 
29 |       mkdir -p "$out/bin"
30 |       makeWrapper "$initPath" \
31 |         "$out/bin/burpsuite" \
32 |         --add-flags "${extraFlags}"
33 | 
34 |       cp -r "$src/share" "$out/share"
35 | 
36 |       runHook postInstall
37 |   '';
38 | }
39 | 


--------------------------------------------------------------------------------
/workspace/additional/ghidra.nix:
--------------------------------------------------------------------------------
 1 | { pkgs }:
 2 | 
 3 | # ghidra will spam-log stack traces into the home directory when not run in a desktop environment
 4 | 
 5 | let
 6 |   inherit (pkgs.ghidra) pname version meta;
 7 | 
 8 |   description = "Software reverse engineering (SRE) suite of tools developed by NSA's Research Directorate in support of the Cybersecurity mission";
 9 | 
10 | in pkgs.stdenv.mkDerivation {
11 |   inherit pname version meta description;
12 | 
13 |   src = pkgs.ghidra;
14 | 
15 |   buildInputs = [ pkgs.makeWrapper ];
16 | 
17 |   installPhase = ''
18 |       runHook preInstall
19 | 
20 |       mkdir -p "$out/bin"
21 |       makeWrapper "$src/bin/ghidra" \
22 |         "$out/bin/ghidra" \
23 |         --run 'if [ -z "$DISPLAY" ]; then echo "Error: DISPLAY is not set. Please run under desktop environment." >&2; exit 1; fi'
24 | 
25 |       cp -r "$src/share" "$out/share"
26 | 
27 |       runHook postInstall
28 |   '';
29 | }
30 | 


--------------------------------------------------------------------------------
/workspace/core/exec-suid.nix:
--------------------------------------------------------------------------------
 1 | { pkgs }:
 2 | 
 3 | pkgs.rustPlatform.buildRustPackage rec {
 4 |   pname = "exec-suid";
 5 |   version = "0.1.5";
 6 | 
 7 |   src = pkgs.fetchFromGitHub {
 8 |     owner = "pwncollege";
 9 |     repo = pname;
10 |     rev = "v${version}";
11 |     sha256 = "sha256-k9d6NbgnkbJXF9Eefh/CaM4GrsMNO9UtIBMp8U5AAwM=";
12 |   };
13 | 
14 |   cargoLock = {
15 |     lockFile = "${src}/Cargo.lock";
16 |   };
17 | 
18 |   meta = with pkgs.lib; {
19 |     description = "A simple interface for running scripts as suid";
20 |     license = licenses.bsd2;
21 |     platforms = platforms.linux;
22 |     suid = [ "bin/exec-suid" ];
23 |   };
24 | }
25 | 


--------------------------------------------------------------------------------
/workspace/core/init.nix:
--------------------------------------------------------------------------------
 1 | { pkgs }:
 2 | 
 3 | let
 4 |   initScript = pkgs.writeScript "dojo-init" ''
 5 |     #!${pkgs.bash}/bin/bash
 6 | 
 7 |     IMAGE_PATH="$(echo $PATH | cut -d: -f3-)"
 8 |     DEFAULT_PROFILE="/nix/var/nix/profiles/dojo-workspace"
 9 | 
10 |     export PATH="$DEFAULT_PROFILE/bin:$PATH"
11 | 
12 |     mkdir -p /run/current-system
13 |     ln -sfT $DEFAULT_PROFILE /run/current-system/sw
14 | 
15 |     mkdir -p /run/dojo
16 |     for path in /run/current-system/sw/*; do
17 |       ln -sfT $path /run/dojo/$(basename $path)
18 |     done
19 | 
20 |     mkdir -pm 1777 /run/dojo/var /tmp
21 |     mkdir /run/dojo/var/root
22 | 
23 |     if [ ! -e /run/challenge/bin ]; then
24 |       mkdir -p /run/challenge && ln -sfT /challenge/bin /run/challenge/bin
25 |     fi
26 | 
27 |     if [ ! -e /bin/sh ]; then
28 |       mkdir -p /bin && ln -sfT /run/dojo/bin/sh /bin/sh
29 |     fi
30 | 
31 |     mkdir -p /home/hacker /root
32 |     mkdir -p /etc /etc/profile.d && touch /etc/passwd /etc/group
33 |     echo "root:x:0:0:root:/root:/run/dojo/bin/bash" >> /etc/passwd
34 |     echo "hacker:x:1000:1000:hacker:/home/hacker:/run/dojo/bin/bash" >> /etc/passwd
35 |     echo "sshd:x:112:65534::/run/sshd:/usr/sbin/nologin" >> /etc/passwd
36 |     echo "root:x:0:" >> /etc/group
37 |     echo "hacker:x:1000:" >> /etc/group
38 |     echo "PATH=\"/run/challenge/bin:/run/workspace/bin:$IMAGE_PATH\"" > /etc/environment
39 |     ln -sfT /run/dojo/etc/profile.d/99-dojo-workspace.sh /etc/profile.d/99-dojo-workspace.sh
40 | 
41 |     echo $DOJO_AUTH_TOKEN > /run/dojo/var/auth_token
42 | 
43 |     echo "Initialized."
44 | 
45 |     read DOJO_FLAG
46 |     echo $DOJO_FLAG | install -m 400 /dev/stdin /flag
47 | 
48 |     exec > /run/dojo/var/root/init.log 2>&1
49 |     chmod 600 /run/dojo/var/root/init.log
50 | 
51 |     for path in /home/hacker /home/hacker/.config; do
52 |       mkdir -p "$path" && chown 1000:1000 "$path" && chmod 755 "$path"
53 |     done
54 | 
55 |     if [ -x "/challenge/.init" ]; then
56 |         PATH="/run/challenge/bin:$IMAGE_PATH" /challenge/.init
57 |     fi
58 | 
59 |     touch /run/dojo/var/ready
60 | 
61 |     exec "$@"
62 |   '';
63 | 
64 |   profile = pkgs.writeText "dojo-profile" ''
65 |     if [[ "$PATH" != "/run/challenge/bin:/run/workspace/bin:"* ]]; then
66 |       export PATH="/run/challenge/bin:/run/workspace/bin:$PATH"
67 |     fi
68 | 
69 |     if [[ -z "$LANG" ]]; then
70 |       export LANG="C.UTF-8"
71 |     fi
72 | 
73 |     if [[ -z "$MANPATH" ]]; then
74 |       # "If the value of $MANPATH ends with a colon, then the default search path is added at its end."
75 |       export MANPATH="/run/dojo/share/man:"
76 |     fi
77 | 
78 |     if [[ -z "$SSL_CERT_FILE" ]]; then
79 |       export SSL_CERT_FILE="/run/dojo/etc/ssl/certs/ca-bundle.crt"
80 |     fi
81 | 
82 |     PROMPT_COMMAND="history -a; $PROMPT_COMMAND"
83 |   '';
84 | 
85 | in pkgs.stdenv.mkDerivation {
86 |   name = "init";
87 |   buildInputs = [ pkgs.bash ];
88 |   dontUnpack = true;
89 | 
90 |   installPhase = ''
91 |     runHook preInstall
92 |     mkdir -p $out/bin $out/etc/profile.d
93 |     cp ${initScript} $out/bin/dojo-init
94 |     cp ${profile} $out/etc/profile.d/99-dojo-workspace.sh
95 |     runHook postInstall
96 |   '';
97 | }
98 | 


--------------------------------------------------------------------------------
/workspace/core/ssh-entrypoint.nix:
--------------------------------------------------------------------------------
 1 | { pkgs }:
 2 | 
 3 | let
 4 |   sshEntryPoint = pkgs.writeScript "ssh-entrypoint" ''
 5 |     #!${pkgs.bashInteractive}/bin/bash
 6 | 
 7 |     if [ "$#" -gt 0 ]; then
 8 |       $SHELL "$@"
 9 |     else
10 |       $SHELL --login
11 |     fi
12 | 
13 |     exit $?
14 |   '';
15 | 
16 | in pkgs.stdenv.mkDerivation {
17 |   name = "ssh-entrypoint";
18 |   propagatedBuildInputs = with pkgs; [ bashInteractive ];
19 |   dontUnpack = true;
20 | 
21 |   installPhase = ''
22 |     runHook preInstall
23 |     mkdir -p $out/bin
24 |     cp ${sshEntryPoint} $out/bin/ssh-entrypoint
25 |     runHook postInstall
26 |   '';
27 | }
28 | 


--------------------------------------------------------------------------------
/workspace/core/sudo.nix:
--------------------------------------------------------------------------------
 1 | { pkgs }:
 2 | 
 3 | let
 4 |   exec-suid = import ./exec-suid.nix { inherit pkgs; };
 5 | 
 6 | in pkgs.stdenv.mkDerivation {
 7 |   name = "sudo";
 8 |   src = ./sudo.py;
 9 | 
10 |   buildInputs = [ exec-suid pkgs.python3 ];
11 | 
12 |   unpackPhase = ''
13 |     runHook preUnpack
14 |     cp $src $PWD
15 |     runHook postUnpack
16 |   '';
17 | 
18 |   installPhase = ''
19 |     runHook preInstall
20 |     mkdir -p $out/bin
21 |     echo "#!${exec-suid}/bin/exec-suid -- ${pkgs.python3}/bin/python3" > $out/bin/sudo
22 |     cat ${./sudo.py} >> $out/bin/sudo
23 |     chmod +x $out/bin/sudo
24 |     runHook postInstall
25 |   '';
26 | 
27 |   meta = with pkgs.lib; {
28 |     description = "A simple sudo implementation";
29 |     license = licenses.bsd2;
30 |     platforms = platforms.linux;
31 |     suid = [ "bin/sudo" ];
32 |   };
33 | }
34 | 


--------------------------------------------------------------------------------
/workspace/core/sudo.py:
--------------------------------------------------------------------------------
 1 | import argparse
 2 | import grp
 3 | import os
 4 | import pwd
 5 | import shutil
 6 | import sys
 7 | 
 8 | 
 9 | def error(message):
10 |     print(message, file=sys.stderr)
11 |     sys.exit(1)
12 | 
13 | 
14 | def main():
15 |     program = os.path.basename(sys.argv[0])
16 | 
17 |     parser = argparse.ArgumentParser(description="execute a command as another user")
18 |     parser.add_argument("-u", "--user", help="run command as specified user", default="0")
19 |     parser.add_argument("command", help="command to execute")
20 |     parser.add_argument("args", nargs=argparse.REMAINDER, help="arguments for command")
21 | 
22 |     args = parser.parse_args()
23 | 
24 |     privileged = int(open("/run/dojo/sys/workspace/privileged", "r").read())
25 |     if not privileged:
26 |         error(f"{program}: workspace is not privileged")
27 | 
28 |     for user in pwd.getpwall():
29 |         if args.user in (user.pw_name, str(user.pw_uid)):
30 |             break
31 |     else:
32 |         error(f"{program}: unknown user: {args.user}")
33 | 
34 |     groups = [group.gr_id for group in grp.getgrall() if user.pw_name in group.gr_mem]
35 |     if user.pw_gid not in groups:
36 |         groups.append(user.pw_gid)
37 | 
38 |     os.setgid(user.pw_gid)
39 |     os.setgroups(groups)
40 |     os.setuid(user.pw_uid)
41 | 
42 |     os.environ["HOME"] = user.pw_dir
43 |     os.environ["USER"] = user.pw_name
44 |     os.environ["SHELL"] = user.pw_shell
45 | 
46 |     command_path = shutil.which(args.command)
47 |     if not command_path:
48 |         error(f"{program}: {args.command}: command not found")
49 | 
50 |     try:
51 |         os.execve(command_path, [args.command, *args.args], os.environ)
52 |     except:
53 |         os.exit(1)
54 | 
55 | 
56 | if __name__ == "__main__":
57 |     main()
58 | 


--------------------------------------------------------------------------------
/workspace/services/code.nix:
--------------------------------------------------------------------------------
 1 | { pkgs }:
 2 | 
 3 | let
 4 |   service = import ./service.nix { inherit pkgs; };
 5 | 
 6 |   rgScript = pkgs.writeScript "rg" ''
 7 |     #!${pkgs.python3}/bin/python3
 8 | 
 9 |     import sys
10 |     import os
11 | 
12 |     sys.argv[0] += ".orig"
13 |     if "--follow" in sys.argv:
14 |         sys.argv.remove("--follow")
15 |     os.execv(sys.argv[0], sys.argv)
16 |   '';
17 |   code-server = pkgs.stdenv.mkDerivation {
18 |     name = "code-server";
19 |     src = pkgs.code-server;
20 |     buildInputs = with pkgs; [ nodejs makeWrapper ];
21 |     installPhase = ''
22 |       runHook preInstall
23 |       rgBin=libexec/code-server/lib/vscode/node_modules/@vscode/ripgrep/bin
24 |       mkdir -p $out/$rgBin
25 |       cp ${rgScript} $out/$rgBin/rg
26 |       cp ${pkgs.code-server}/$rgBin/rg $out/$rgBin/rg.orig
27 |       cp -ru ${pkgs.code-server}/libexec/code-server/. $out/libexec/code-server
28 |       mkdir -p $out/bin
29 |       makeWrapper ${pkgs.nodejs}/bin/node $out/bin/code-server --add-flags $out/libexec/code-server/out/node/entry.js
30 |       runHook postInstall
31 |     '';
32 |   };
33 | 
34 |   serviceScript = pkgs.writeScript "dojo-code" ''
35 |     #!${pkgs.bash}/bin/bash
36 | 
37 |     until [ -f /run/dojo/var/ready ]; do sleep 0.1; done
38 | 
39 |     if [ -d /run/challenge/share/code/extensions ]; then
40 |       EXTENSIONS_DIR="/run/challenge/share/code/extensions"
41 |     else
42 |       EXTENSIONS_DIR="@out@/share/code/extensions"
43 |     fi
44 | 
45 |     ${service}/bin/dojo-service start code-service/code-server \
46 |       ${code-server}/bin/code-server \
47 |         --auth=none \
48 |         --bind-addr=0.0.0.0:8080 \
49 |         --trusted-origins='*' \
50 |         --disable-telemetry \
51 |         --extensions-dir=$EXTENSIONS_DIR \
52 |         --config=/dev/null
53 | 
54 |     until ${pkgs.curl}/bin/curl -s localhost:8080 >/dev/null; do sleep 0.1; done
55 |   '';
56 | 
57 | in pkgs.stdenv.mkDerivation {
58 |   name = "code-service";
59 |   buildInputs = with pkgs; [
60 |     code-server
61 |     bash
62 |     python3
63 |     wget
64 |     curl
65 |     cacert
66 |   ];
67 |   dontUnpack = true;
68 | 
69 |   installPhase = ''
70 |     runHook preInstall
71 | 
72 |     mkdir -p $out/bin
73 |     substitute ${serviceScript} $out/bin/dojo-code \
74 |       --subst-var-by out $out
75 |     chmod +x $out/bin/dojo-code
76 |     ln -s ${code-server}/bin/code-server $out/bin/code-server
77 |     ln -s ${code-server}/bin/code-server $out/bin/code
78 | 
79 |     mkdir -p $out/share/code/extensions
80 |     ${pkgs.wget}/bin/wget -P $NIX_BUILD_TOP 'https://github.com/microsoft/vscode-cpptools/releases/download/v1.20.5/cpptools-linux.vsix'
81 |     export HOME=$NIX_BUILD_TOP
82 |     ${code-server}/bin/code-server \
83 |       --auth=none \
84 |       --disable-telemetry \
85 |       --extensions-dir=$out/share/code/extensions \
86 |       --install-extension ms-python.python \
87 |       --install-extension juanblanco.solidity \
88 |       --install-extension $NIX_BUILD_TOP/cpptools-linux.vsix
89 |     chmod +x $out/share/code/extensions/ms-vscode.cpptools-*/{bin/cpptools*,bin/libc.so,debugAdapters/bin/OpenDebugAD7,LLVM/bin/clang-*}
90 | 
91 |     runHook postInstall
92 |   '';
93 | }
94 | 


--------------------------------------------------------------------------------
/workspace/services/desktop.nix:
--------------------------------------------------------------------------------
  1 | { pkgs }:
  2 | 
  3 | let
  4 |   service = import ./service.nix { inherit pkgs; };
  5 | 
  6 |   # Revert https://github.com/novnc/noVNC/pull/1672
  7 |   reconnectPatch = pkgs.writeText "reconnect_patch.diff" ''
  8 |     --- a/share/webapps/novnc/app/ui.js
  9 |     +++ b/share/webapps/novnc/app/ui.js
 10 |     @@ -1,3 +1,3 @@
 11 |     -        if (UI.getSetting('reconnect', false) === true && !UI.inhibitReconnect) {
 12 |     +        else if (UI.getSetting('reconnect', false) === true && !UI.inhibitReconnect) {
 13 |   '';
 14 |   novnc = pkgs.novnc.overrideAttrs (oldAttrs: {
 15 |     postInstall = (oldAttrs.postInstall or "") + ''
 16 |       patch -p1 -d $out < ${reconnectPatch}
 17 |     '';
 18 |   });
 19 | 
 20 |   serviceScript = pkgs.writeScript "dojo-desktop" ''
 21 |     #!${pkgs.bash}/bin/bash
 22 | 
 23 |     until [ -f /run/dojo/var/ready ]; do sleep 0.1; done
 24 | 
 25 |     export DISPLAY=:0
 26 |     export XDG_DATA_DIRS="/run/dojo/share:''${XDG_DATA_DIRS:-/usr/local/share:/usr/share}"
 27 |     export XDG_CONFIG_DIRS="/run/dojo/etc/xdg:''${XDG_CONFIG_DIRS:-/etc/xdg}"
 28 | 
 29 |     auth_token="$(cat /run/dojo/var/auth_token)"
 30 |     password_interact="$(printf 'desktop-interact' | ${pkgs.openssl}/bin/openssl dgst -sha256 -hmac "$auth_token" | awk '{print $2}' | head -c 8)"
 31 |     password_view="$(printf 'desktop-view' | ${pkgs.openssl}/bin/openssl dgst -sha256 -hmac "$auth_token" | awk '{print $2}' | head -c 8)"
 32 | 
 33 |     mkdir -p /run/dojo/var/desktop-service
 34 |     printf '%s\n%s\n' "$password_interact" "$password_view" | ${pkgs.tigervnc}/bin/vncpasswd -f > /run/dojo/var/desktop-service/Xvnc.passwd
 35 | 
 36 |     ${service}/bin/dojo-service start desktop-service/Xvnc \
 37 |       ${pkgs.tigervnc}/bin/Xvnc \
 38 |         $DISPLAY \
 39 |         -localhost 0 \
 40 |         -rfbunixpath /run/dojo/var/desktop-service/Xvnc.sock \
 41 |         -rfbauth /run/dojo/var/desktop-service/Xvnc.passwd \
 42 |         -nolisten tcp \
 43 |         -geometry 1024x768 \
 44 |         -depth 24
 45 | 
 46 |     ${service}/bin/dojo-service start desktop-service/novnc \
 47 |       ${novnc}/bin/novnc \
 48 |         --vnc --unix-target=/run/dojo/var/desktop-service/Xvnc.sock \
 49 |         --listen 6080
 50 | 
 51 |     until [ -e /tmp/.X11-unix/X0 ]; do sleep 0.1; done
 52 |     until ${pkgs.curl}/bin/curl -s localhost:6080 >/dev/null; do sleep 0.1; done
 53 | 
 54 |     # By default, xfce4-session invokes dbus-launch without `--config-file`, and it fails to find /etc/dbus-1/session.conf; so we manually specify the config file here.
 55 |     ${service}/bin/dojo-service start desktop-service/xfce4-session \
 56 |       ${pkgs.dbus}/bin/dbus-launch --sh-syntax --exit-with-session --config-file=${pkgs.dbus}/share/dbus-1/session.conf ${pkgs.xfce.xfce4-session}/bin/xfce4-session
 57 |   '';
 58 | 
 59 |   xfce = pkgs.symlinkJoin {
 60 |     name = "xfce";
 61 |     paths = with pkgs.xfce; [
 62 |       xfce4-session
 63 |       xfce4-settings
 64 |       xfce4-terminal
 65 |       xfce4-panel
 66 |       xfce4-appfinder
 67 |       xfwm4
 68 |       xfdesktop
 69 |       xfconf
 70 |       exo
 71 |       thunar
 72 |     ] ++ (with pkgs; [
 73 |       dbus
 74 |       dejavu_fonts
 75 |       blackbird
 76 |     ]);
 77 |   };
 78 | 
 79 | in pkgs.stdenv.mkDerivation {
 80 |   name = "desktop-service";
 81 |   src = ./desktop;
 82 | 
 83 |   buildInputs = with pkgs; [
 84 |     bash
 85 |     openssl
 86 |     curl
 87 |     rsync
 88 |   ];
 89 |   propagatedBuildInputs = with pkgs; [
 90 |     tigervnc
 91 |     novnc
 92 |     xfce
 93 |     elementary-xfce-icon-theme  # If we include this in `xfce`, we get a "Permission denied" error related to `nix-support/propagated-build-inputs`.
 94 |   ];
 95 | 
 96 |   dontMoveSystemdUserUnits = true;  # We run into an issue where we `mv` "the same file".
 97 | 
 98 |   unpackPhase = ''
 99 |     runHook preUnpack
100 |     cp -r $src $PWD
101 |     runHook postUnpack
102 |   '';
103 | 
104 |   installPhase = ''
105 |     runHook preInstall
106 |     mkdir -p $out/bin
107 |     cp ${serviceScript} $out/bin/dojo-desktop
108 |     rsync -a --ignore-existing $src/. ${xfce}/. ${pkgs.elementary-xfce-icon-theme}/. $out
109 |     runHook postInstall
110 |   '';
111 | }
112 | 


--------------------------------------------------------------------------------
/workspace/services/desktop/etc/xdg/xfce4/xfconf/xfce-perchannel-xml/xfce4-desktop.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <channel name="xfce4-desktop" version="1.0">
 3 |   <property name="backdrop" type="empty">
 4 |     <property name="screen0" type="empty">
 5 |       <property name="monitorVNC-0" type="empty">
 6 |         <property name="workspace0" type="empty">
 7 |           <property name="last-image" type="string" value="/run/dojo/share/backgrounds/pwncollege-background.png"/>
 8 |         </property>
 9 |       </property>
10 |     </property>
11 |   </property>
12 | </channel>
13 | 


--------------------------------------------------------------------------------
/workspace/services/desktop/etc/xdg/xfce4/xfconf/xfce-perchannel-xml/xfce4-terminal.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <channel name="xfce4-terminal" version="1.0">
 3 |   <property name="font-name" type="string" value="DejaVu Sans Mono 12"/>
 4 |   <property name="color-palette" type="string" value="#000000;#cd3131;#0dbc79;#e5e510;#2472c8;#bc3fbc;#11a8cd;#e5e5e5;#666666;#f14c4c;#23d18b;#f5f543;#3b8eea;#d670d6;#29b8db;#e5e5e5"/>
 5 |   <property name="color-foreground" type="string" value="#ffffff"/>
 6 |   <property name="color-background" type="string" value="#181818"/>
 7 |   <property name="color-cursor-use-default" type="bool" value="false"/>
 8 |   <property name="color-cursor" type="string" value="#cccccc"/>
 9 |   <property name="color-selection-use-default" type="bool" value="false"/>
10 |   <property name="color-selection-background" type="string" value="#264f78"/>
11 |   <property name="command-login-shell" type="bool" value="true"/>
12 | </channel>
13 | 


--------------------------------------------------------------------------------
/workspace/services/desktop/etc/xdg/xfce4/xfconf/xfce-perchannel-xml/xfwm4.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <channel name="xfwm4" version="1.0">
3 |   <property name="general" type="empty">
4 |     <property name="title_font" type="string" value="DejaVu Sans Bold 10"/>
5 |   </property>
6 | </channel>
7 | 


--------------------------------------------------------------------------------
/workspace/services/desktop/etc/xdg/xfce4/xfconf/xfce-perchannel-xml/xsettings.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <channel name="xsettings" version="1.0">
 3 |   <property name="Net" type="empty">
 4 |     <property name="ThemeName" type="string" value="Blackbird"/>
 5 |     <property name="IconThemeName" type="string" value="elementary-xfce-dark"/>
 6 |   </property>
 7 |   <property name="Gtk" type="empty">
 8 |     <property name="FontName" type="string" value="DejaVu Sans 11"/>
 9 |     <property name="MonospaceFontName" type="string" value="DejaVu Sans Mono 11"/>
10 |     <property name="MenuImages" type="bool" value="true"/>
11 |   </property>
12 | </channel>
13 | 


--------------------------------------------------------------------------------
/workspace/services/desktop/share/backgrounds/pwncollege-background.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pwncollege/dojo/601dfe3af5eebbfd0973b79a8c35909e25df492e/workspace/services/desktop/share/backgrounds/pwncollege-background.png


--------------------------------------------------------------------------------
/workspace/services/service.nix:
--------------------------------------------------------------------------------
 1 | { pkgs }:
 2 | 
 3 | pkgs.stdenv.mkDerivation {
 4 |   name = "dojo-service";
 5 |   src = ./service.py;
 6 | 
 7 |   buildInputs = [ pkgs.python3 ];
 8 | 
 9 |   unpackPhase = ''
10 |     runHook preUnpack
11 |     cp $src $PWD
12 |     runHook postUnpack
13 |   '';
14 | 
15 |   installPhase = ''
16 |     runHook preInstall
17 |     mkdir -p $out/bin
18 |     echo "#!${pkgs.python3.interpreter}" > $out/bin/dojo-service
19 |     cat ${./service.py} >> $out/bin/dojo-service
20 |     chmod +x $out/bin/dojo-service
21 |     runHook postInstall
22 |   '';
23 | }
24 | 


--------------------------------------------------------------------------------
/workspace/services/service.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import sys
  3 | import signal
  4 | import argparse
  5 | from pathlib import Path
  6 | 
  7 | RUN_DIR = Path("/run/dojo/var")
  8 | 
  9 | def daemonize(service_name, exec_command):
 10 |     try:
 11 |         pid = os.fork()
 12 |         if pid > 0:
 13 |             sys.exit(0)
 14 |     except OSError as e:
 15 |         sys.stderr.write(f"Fork #1 failed: {e.errno} ({e.strerror})\n")
 16 |         sys.exit(1)
 17 | 
 18 |     os.setsid()
 19 | 
 20 |     try:
 21 |         pid = os.fork()
 22 |         if pid > 0:
 23 |             sys.exit(0)
 24 |     except OSError as e:
 25 |         sys.stderr.write(f"Fork #2 failed: {e.errno} ({e.strerror})\n")
 26 |         sys.exit(1)
 27 | 
 28 |     sys.stdout.flush()
 29 |     sys.stderr.flush()
 30 | 
 31 |     log_file = RUN_DIR / f"{service_name}.log"
 32 |     with open('/dev/null', 'r') as f:
 33 |         os.dup2(f.fileno(), sys.stdin.fileno())
 34 |     with open(log_file, 'a+') as f:
 35 |         os.dup2(f.fileno(), sys.stdout.fileno())
 36 |         os.dup2(f.fileno(), sys.stderr.fileno())
 37 | 
 38 |     pid_file = RUN_DIR / f"{service_name}.pid"
 39 |     pid_file.write_text(str(os.getpid()))
 40 | 
 41 |     os.execve(exec_command[0], exec_command, os.environ)
 42 | 
 43 | def start_service(service_name, exec_command):
 44 |     pid_file = RUN_DIR / f"{service_name}.pid"
 45 |     if pid_file.exists():
 46 |         try:
 47 |             pid = int(pid_file.read_text())
 48 |             os.kill(pid, 0)
 49 |         except (OSError, ValueError):
 50 |             pass
 51 |         else:
 52 |             print(f"Service {service_name} is already running.")
 53 |             return
 54 | 
 55 |     service_dir = (RUN_DIR / service_name).parent
 56 |     service_dir.mkdir(parents=True, exist_ok=True)
 57 | 
 58 |     daemonize(service_name, exec_command)
 59 |     print(f"Service {service_name} started.")
 60 | 
 61 | def terminate_service(service_name, signal):
 62 |     pid_file = RUN_DIR / f"{service_name}.pid"
 63 |     if not pid_file.exists():
 64 |         print(f"Service {service_name} is not running.")
 65 |         return
 66 | 
 67 |     try:
 68 |         pid = int(pid_file.read_text())
 69 |         os.kill(pid, signal.SIGTERM)
 70 |     except (OSError, ValueError, ProcessLookupError):
 71 |         pass
 72 | 
 73 |     if pid_file.exists():
 74 |         pid_file.unlink()
 75 |     print(f"Service {service_name} stopped.")
 76 | 
 77 | stop_service = lambda service_name: terminate_service(service_name, signal.SIGTERM)
 78 | kill_service = lambda service_name: terminate_service(service_name, signal.SIGKILL)
 79 | 
 80 | def status_service(service_name):
 81 |     if (RUN_DIR / service_name).is_dir():
 82 |         for pid_file in RUN_DIR.rglob("*.pid"):
 83 |             service_name = pid_file.relative_to(RUN_DIR).with_suffix("")
 84 |             status_service(service_name)
 85 |         return
 86 | 
 87 |     pid_file = RUN_DIR / f"{service_name}.pid"
 88 |     if pid_file.exists():
 89 |         try:
 90 |             with pid_file.open('r') as f:
 91 |                 pid = int(f.read())
 92 |             os.kill(pid, 0)
 93 |             print(f"Service {service_name} is running with PID {pid}.")
 94 |         except (OSError, ValueError):
 95 |             print(f"Service {service_name} PID file found, but process is not running.")
 96 |     else:
 97 |         print(f"Service {service_name} is not running.")
 98 | 
 99 | if __name__ == "__main__":
100 |     parser = argparse.ArgumentParser(description="Python start-stop-daemon")
101 |     parser.add_argument("command", choices=["start", "stop", "kill", "status"], help="Command to run")
102 |     parser.add_argument("service_name", help="Name of the service")
103 |     parser.add_argument("exec_command", help="Command to execute for the service", nargs=argparse.REMAINDER)
104 |     args = parser.parse_args()
105 | 
106 |     if args.command == "start":
107 |         start_service(args.service_name, args.exec_command)
108 |     elif args.command == "stop":
109 |         stop_service(args.service_name)
110 |     elif args.command == "kill":
111 |         kill_service(args.service_name)
112 |     elif args.command == "status":
113 |         status_service(args.service_name)
114 | 


--------------------------------------------------------------------------------
/workspacefs/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM alpine:latest
 2 | 
 3 | RUN apk add --no-cache \
 4 |     fuse \
 5 |     fuse-dev \
 6 |     gcc \
 7 |     musl-dev
 8 | 
 9 | COPY workspacefs.c /tmp/workspacefs.c
10 | RUN gcc -Wall /tmp/workspacefs.c `pkg-config fuse --cflags --libs` -o /bin/workspacefs && \
11 |     rm /tmp/workspacefs.c && \
12 |     mkdir -p /run/dojo && \
13 |     ln -sfT /nix/var/nix/profiles/dojo-workspace/bin /run/dojo/bin
14 | 
15 | CMD ["/bin/workspacefs", "-f", "-o", "allow_other", "/run/workspace/bin"]
16 | 


--------------------------------------------------------------------------------
/workspacefs/workspacefs.c:
--------------------------------------------------------------------------------
 1 | #define FUSE_USE_VERSION 30
 2 | 
 3 | #include <stdio.h>
 4 | #include <string.h>
 5 | #include <errno.h>
 6 | #include <unistd.h>
 7 | #include <sys/types.h>
 8 | #include <sys/stat.h>
 9 | #include <dirent.h>
10 | #include <limits.h>
11 | 
12 | #include <fuse.h>
13 | 
14 | static int workspace_accessible(const char *path)
15 | {
16 |     uid_t uid = fuse_get_context()->uid;
17 |     gid_t gid = fuse_get_context()->gid;
18 |     return uid == 1000 || uid == gid || !strcmp(path, "/sudo");
19 | }
20 | 
21 | static int workspace_exists(const char *path, char *real_path)
22 | {
23 |     snprintf(real_path, PATH_MAX, "/run/dojo/bin%s", path);
24 |     struct stat real_stat;
25 |     return stat(real_path, &real_stat) == 0;
26 | }
27 | 
28 | static int workspace_getattr(const char *path, struct stat *stbuf)
29 | {
30 |     if (strcmp(path, "/") == 0) {
31 |         stbuf->st_mode = S_IFDIR | 0755;
32 |         stbuf->st_nlink = 2;
33 |         return 0;
34 |     }
35 | 
36 |     char real_path[PATH_MAX];
37 |     if (!workspace_accessible(path) || !workspace_exists(path, real_path))
38 |         return -ENOENT;
39 | 
40 |     memset(stbuf, 0, sizeof(struct stat));
41 |     stbuf->st_mode = S_IFLNK | 0777;
42 |     stbuf->st_nlink = 1;
43 |     stbuf->st_uid = 0;
44 |     stbuf->st_gid = 0;
45 |     stbuf->st_size = strlen(real_path);
46 |     return 0;
47 | }
48 | 
49 | static int workspace_readdir(const char *path, void *buf, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi)
50 | {
51 |     if (strcmp(path, "/") != 0) {
52 |         return -ENOENT;
53 |     }
54 | 
55 |     filler(buf, ".", NULL, 0);
56 |     filler(buf, "..", NULL, 0);
57 | 
58 |     if (!workspace_accessible(path))
59 |         return 0;
60 | 
61 |     DIR *dp = opendir("/run/dojo/bin");
62 |     if (dp == NULL)
63 |         return -errno;
64 | 
65 |     struct dirent *de;
66 |     while ((de = readdir(dp)) != NULL) {
67 |         struct stat st;
68 |         memset(&st, 0, sizeof(st));
69 |         st.st_ino = de->d_ino;
70 |         st.st_mode = S_IFLNK | 0777;
71 |         if (filler(buf, de->d_name, &st, 0))
72 |             break;
73 |     }
74 |     closedir(dp);
75 | 
76 |     return 0;
77 | }
78 | 
79 | static int workspace_readlink(const char *path, char *buf, size_t size)
80 | {
81 |     char real_path[PATH_MAX];
82 |     if (!workspace_accessible(path) || !workspace_exists(path, real_path))
83 |         return -ENOENT;
84 | 
85 |     snprintf(buf, size, "%s", real_path);
86 |     return 0;
87 | }
88 | 
89 | static struct fuse_operations workspace_operations = {
90 |     .getattr  = workspace_getattr,
91 |     .readdir  = workspace_readdir,
92 |     .readlink = workspace_readlink,
93 | };
94 | 
95 | int main(int argc, char *argv[])
96 | {
97 |     return fuse_main(argc, argv, &workspace_operations, NULL);
98 | }
99 | 


--------------------------------------------------------------------------------