├── .editorconfig
├── .github
    └── workflows
    │   ├── lint.yml
    │   ├── release.yml
    │   └── test.yml
├── .gitignore
├── CHANGELOG.md
├── LICENSE
├── Makefile
├── README.md
├── ctfcli
    ├── __init__.py
    ├── __main__.py
    ├── cli
    │   ├── __init__.py
    │   ├── challenges.py
    │   ├── config.py
    │   ├── instance.py
    │   ├── media.py
    │   ├── pages.py
    │   ├── plugins.py
    │   └── templates.py
    ├── core
    │   ├── __init__.py
    │   ├── api.py
    │   ├── challenge.py
    │   ├── config.py
    │   ├── deployment
    │   │   ├── __init__.py
    │   │   ├── base.py
    │   │   ├── cloud.py
    │   │   ├── registry.py
    │   │   └── ssh.py
    │   ├── exceptions.py
    │   ├── image.py
    │   ├── instance
    │   │   ├── __init__.py
    │   │   └── config.py
    │   ├── media.py
    │   ├── page.py
    │   └── plugins.py
    ├── spec
    │   └── challenge-example.yml
    ├── templates
    │   ├── binary
    │   │   └── default
    │   │   │   ├── cookiecutter.json
    │   │   │   └── {{cookiecutter.name}}
    │   │   │       ├── .dockerignore
    │   │   │       ├── Makefile
    │   │   │       ├── README.md
    │   │   │       ├── challenge.yml
    │   │   │       ├── src
    │   │   │           └── {{cookiecutter.name}}.c
    │   │   │       └── writeup
    │   │   │           └── WRITEUP.md
    │   ├── blank
    │   │   ├── default
    │   │   │   ├── cookiecutter.json
    │   │   │   └── {{cookiecutter.name}}
    │   │   │   │   ├── README.md
    │   │   │   │   ├── challenge.yml
    │   │   │   │   ├── src
    │   │   │   │       └── placeholder
    │   │   │   │   └── writeup
    │   │   │   │       └── WRITEUP.md
    │   │   └── empty
    │   │   │   ├── cookiecutter.json
    │   │   │   └── {{cookiecutter.dirname}}
    │   │   │       └── challenge.yml
    │   ├── crypto
    │   │   └── default
    │   │   │   ├── cookiecutter.json
    │   │   │   └── {{cookiecutter.name}}
    │   │   │       ├── .gitignore
    │   │   │       ├── Makefile
    │   │   │       ├── README.md
    │   │   │       ├── challenge.yml
    │   │   │       ├── src
    │   │   │           ├── encrypt.py
    │   │   │           └── flag.txt
    │   │   │       └── writeup
    │   │   │           └── WRITEUP.md
    │   ├── programming
    │   │   └── default
    │   │   │   ├── cookiecutter.json
    │   │   │   └── {{cookiecutter.name}}
    │   │   │       ├── .dockerignore
    │   │   │       ├── .gitignore
    │   │   │       ├── Dockerfile
    │   │   │       ├── README.md
    │   │   │       ├── challenge.yml
    │   │   │       ├── docker-compose.yml
    │   │   │       ├── src
    │   │   │           ├── requirements.txt
    │   │   │           ├── serve.sh
    │   │   │           └── server.py
    │   │   │       └── writeup
    │   │   │           └── WRITEUP.md
    │   └── web
    │   │   └── default
    │   │       ├── cookiecutter.json
    │   │       └── {{cookiecutter.name}}
    │   │           ├── .dockerignore
    │   │           ├── Dockerfile
    │   │           ├── README.md
    │   │           ├── challenge.yml
    │   │           ├── docker-compose.yml
    │   │           ├── src
    │   │               ├── app.py
    │   │               ├── config.py
    │   │               ├── models.py
    │   │               ├── requirements.txt
    │   │               ├── serve.sh
    │   │               ├── static
    │   │               │   └── css
    │   │               │   │   └── main.css
    │   │               └── templates
    │   │               │   ├── base.html
    │   │               │   ├── index.html
    │   │               │   ├── login.html
    │   │               │   ├── profile.html
    │   │               │   └── register.html
    │   │           └── writeup
    │   │               └── WRITEUP.md
    └── utils
    │   ├── __init__.py
    │   ├── git.py
    │   ├── hashing.py
    │   └── tools.py
├── docs
    └── plugins.md
├── poetry.lock
├── preprocess.py
├── pyproject.toml
└── tests
    ├── __init__.py
    ├── cli
        └── test_main.py
    ├── core
        ├── __init__.py
        ├── deployment
        │   ├── __init__.py
        │   ├── test_base_deployment_handler.py
        │   ├── test_cloud_deployment.py
        │   ├── test_registry_deployment.py
        │   └── test_ssh_deployment.py
        ├── test_api.py
        ├── test_challenge.py
        ├── test_config.py
        ├── test_exceptions.py
        ├── test_image.py
        ├── test_page.py
        └── test_plugins.py
    ├── fixtures
        └── challenges
        │   ├── .ctf
        │       └── config
        │   ├── pages
        │       ├── html-page.html
        │       ├── markdown-page.md
        │       └── nested
        │       │   └── html-page.htm
        │   ├── test-challenge-dockerfile
        │       ├── Dockerfile
        │       ├── challenge.yml
        │       └── src
        │       │   └── index.html
        │   ├── test-challenge-files
        │       ├── challenge.yml
        │       └── files
        │       │   ├── flag.txt
        │       │   ├── test.pdf
        │       │   └── test.png
        │   ├── test-challenge-full
        │       ├── challenge.yml
        │       └── files
        │       │   ├── test.pdf
        │       │   └── test.png
        │   ├── test-challenge-invalid-dockerfile
        │       ├── Dockerfile
        │       └── challenge.yml
        │   ├── test-challenge-invalid
        │       ├── challenge-empty.yml
        │       └── challenge-invalid.yml
        │   └── test-challenge-minimal
        │       └── challenge.yml
    └── utils
        ├── __init__.py
        ├── test_git.py
        └── test_tools.py


/.editorconfig:
--------------------------------------------------------------------------------
 1 | root = true
 2 | 
 3 | [*]
 4 | end_of_line = lf
 5 | insert_final_newline = true
 6 | 
 7 | [*.py]
 8 | charset = utf-8
 9 | indent_style = space
10 | indent_size = 4
11 | 
12 | [Makefile]
13 | indent_style = tab
14 | 


--------------------------------------------------------------------------------
/.github/workflows/lint.yml:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Linting
 3 | 
 4 | on: [push, pull_request]
 5 | 
 6 | jobs:
 7 |   build:
 8 |     runs-on: ubuntu-latest
 9 | 
10 |     strategy:
11 |       matrix:
12 |         python-version: ['3.11']
13 | 
14 |     name: Linting
15 |     steps:
16 |       - uses: actions/checkout@v3
17 |       - name: Setup python
18 |         uses: actions/setup-python@v4
19 |         with:
20 |           python-version: ${{ matrix.python-version }}
21 |           architecture: x64
22 |       - name: Install dependencies
23 |         run: |
24 |             pip install poetry
25 |             poetry install
26 | 
27 |       - name: Lint
28 |         run: poetry run make lint
29 | 


--------------------------------------------------------------------------------
/.github/workflows/release.yml:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Build and Publish
 3 | 
 4 | on:
 5 |   release:
 6 |     types: [published]
 7 |   pull_request:
 8 |     types: [opened, reopened, edited, synchronize]
 9 | 
10 | jobs:
11 |   build:
12 |     # The type of runner that the job will run on
13 |     runs-on: ubuntu-latest
14 |     strategy:
15 |       matrix:
16 |         python-version: [3.11]
17 | 
18 |     # Steps represent a sequence of tasks that will be executed as part of the job
19 |     steps:
20 |       # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
21 |       - uses: actions/checkout@v2
22 | 
23 |       - name: Set up Python
24 |         uses: actions/setup-python@v4
25 |         with:
26 |           python-version: 3.11
27 | 
28 |       - name: Install dependencies
29 |         run: |
30 |             pip install poetry
31 |             poetry install
32 | 
33 |       - name: Build package
34 |         run: poetry build
35 | 
36 |       - uses: actions/upload-artifact@v4
37 |         with:
38 |           path: |
39 |            ./dist/*.tar.gz
40 | 
41 |       - name: Publish to PYPI
42 |         env:
43 |           PYPI_TOKEN: ${{ secrets.PYPI_PASSWORD }}
44 |         if: ${{ github.event_name == 'release' && env.PYPI_TOKEN != null }}
45 |         run: |
46 |           poetry config pypi-token.pypi "$PYPI_TOKEN"
47 |           poetry publish
48 | 


--------------------------------------------------------------------------------
/.github/workflows/test.yml:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Testing
 3 | 
 4 | on: [push, pull_request]
 5 | 
 6 | jobs:
 7 |   build:
 8 |     runs-on: ubuntu-latest
 9 | 
10 |     strategy:
11 |       matrix:
12 |         python-version: ['3.8', '3.9', '3.10', '3.11', '3.12', '3.13']
13 | 
14 |     name: Testing
15 |     steps:
16 |       - uses: actions/checkout@v3
17 |       - name: Setup python
18 |         uses: actions/setup-python@v4
19 |         with:
20 |           python-version: ${{ matrix.python-version }}
21 |           architecture: x64
22 |       - name: Install dependencies
23 |         run: |
24 |             pip install poetry
25 |             poetry install
26 | 
27 |       - name: Test
28 |         run: poetry run make test
29 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | # Byte-compiled / optimized / DLL files
  2 | __pycache__/
  3 | *.py[cod]
  4 | *$py.class
  5 | 
  6 | # C extensions
  7 | *.so
  8 | 
  9 | # Distribution / packaging
 10 | .Python
 11 | build/
 12 | develop-eggs/
 13 | downloads/
 14 | eggs/
 15 | .eggs/
 16 | lib/
 17 | lib64/
 18 | parts/
 19 | dist/
 20 | sdist/
 21 | var/
 22 | wheels/
 23 | pip-wheel-metadata/
 24 | share/python-wheels/
 25 | *.egg-info/
 26 | .installed.cfg
 27 | *.egg
 28 | MANIFEST
 29 | 
 30 | # PyInstaller
 31 | #  Usually these files are written by a python script from a template
 32 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 33 | *.manifest
 34 | *.spec
 35 | 
 36 | # Installer logs
 37 | pip-log.txt
 38 | pip-delete-this-directory.txt
 39 | 
 40 | # Unit test / coverage reports
 41 | htmlcov/
 42 | .tox/
 43 | .nox/
 44 | .coverage
 45 | .coverage.*
 46 | .cache
 47 | nosetests.xml
 48 | coverage.xml
 49 | *.cover
 50 | *.py,cover
 51 | .hypothesis/
 52 | .pytest_cache/
 53 | 
 54 | # Translations
 55 | *.mo
 56 | *.pot
 57 | 
 58 | # Django stuff:
 59 | *.log
 60 | local_settings.py
 61 | db.sqlite3
 62 | db.sqlite3-journal
 63 | 
 64 | # Flask stuff:
 65 | .webassets-cache
 66 | 
 67 | # Scrapy stuff:
 68 | .scrapy
 69 | 
 70 | # Sphinx documentation
 71 | docs/_build/
 72 | 
 73 | # PyBuilder
 74 | target/
 75 | 
 76 | # Jupyter Notebook
 77 | .ipynb_checkpoints
 78 | 
 79 | # IPython
 80 | profile_default/
 81 | ipython_config.py
 82 | 
 83 | # pyenv
 84 | .python-version
 85 | 
 86 | # pipenv
 87 | #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
 88 | #   However, in case of collaboration, if having platform-specific dependencies or dependencies
 89 | #   having no cross-platform support, pipenv may install dependencies that don't work, or not
 90 | #   install all needed dependencies.
 91 | #Pipfile.lock
 92 | 
 93 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow
 94 | __pypackages__/
 95 | 
 96 | # Celery stuff
 97 | celerybeat-schedule
 98 | celerybeat.pid
 99 | 
100 | # SageMath parsed files
101 | *.sage.py
102 | 
103 | # Environments
104 | .env
105 | .venv
106 | env/
107 | venv/
108 | ENV/
109 | env.bak/
110 | venv.bak/
111 | 
112 | # Spyder project settings
113 | .spyderproject
114 | .spyproject
115 | 
116 | # Rope project settings
117 | .ropeproject
118 | 
119 | # mkdocs documentation
120 | /site
121 | 
122 | # mypy
123 | .mypy_cache/
124 | .dmypy.json
125 | dmypy.json
126 | 
127 | # Pyre type checker
128 | .pyre/
129 | 
130 | # Miscellaneous
131 | .DS_Store
132 | .vscode/
133 | .idea/
134 | 
135 | .ctf/
136 | !tests/fixtures/challenges/.ctf
137 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | # Changelog
  2 | 
  3 | # 0.1.4 / 2025-04-29
  4 | 
  5 | ### Added
  6 | 
  7 | - Added support for `ctf instance` with the `ctf instance config` command which can be used to `get` and `set` configuration on CTFd
  8 | - Added `ctf media add`, `ctf media rm`, `ctf media url`
  9 |   - Allows ctfcli repos to manage files locally and reference the actual server URLs of media files in Pages
 10 |   - Adds concept of replacing placeholders like `{{ media/ctfd.png }}` with the actual URL on the server
 11 | - Added the `attribution` field to challenge.yml
 12 | - Added the `next` field to challenge.yml
 13 | - Added ability to anoymize challenges while specifying prerequisites
 14 | - Added specifying CTFd instance URL and access token via envvars: `CTFCLI_URL`, `CTFCLI_ACCESS_TOKEN`
 15 | 
 16 | ### Fixed
 17 | 
 18 | - Fix issue with managing challenges with an empty files section
 19 | - Fix issue where images could not be deployed due to being named incorrectly
 20 | 
 21 | # 0.1.3 / 2024-08-20
 22 | 
 23 | ### Added
 24 | 
 25 | - Added support for `git subrepo` instead of only `git subtree`
 26 | - Added the `--create` switch to `ctf challenge mirror` to create local copies of challenges that exist on a remote CTFd instance
 27 | 
 28 | ### Fixed
 29 | 
 30 | - `ctf challenge {push, pull}` will now push / pull all challenges instead of the challenge in the current working directory.
 31 | 
 32 | ### Changed
 33 | 
 34 | - Use `--load` switch as part of docker build to support alternate build drivers
 35 | 
 36 | # 0.1.2 / 2023-02-26
 37 | 
 38 | ### Added
 39 | 
 40 | - Before uploading files to CTFd, ctfcli will check for CTFd's SHA1 hash of the previously uploaded file and skip uploading if it is the same
 41 | - Support using remote Docker images instead of having to build and push local images
 42 | 
 43 | # 0.1.1 / 2023-12-11
 44 | 
 45 | ### Added
 46 | 
 47 | - Added `ctf challenge mirror` command to pull changes from the remote CTFd instance into the local project
 48 | 
 49 | ### Fixed
 50 | 
 51 | - Properly include challenge.yml when generating a challenge from a template
 52 | 
 53 | ### Changed
 54 | 
 55 | - No longer require a ctfcli project to run all `ctf challenge` (e.g. `new`, `format`, `lint`)
 56 | 
 57 | # 0.1.0 / 2023-10-03
 58 | 
 59 | ### Added
 60 | 
 61 | - ctfcli has been separated into two main modules `cli` and `core`. The `core` module now packages logic previously found inside `utils`, wrapped into classes.
 62 | - The classes in the `core` module will only print out warnings instead of interrupting the whole process. Everything else will throw exceptions which can be caught and handled however desired
 63 | - `cli` and `core` internal modules have type hints
 64 | - Improved error messages
 65 | - Unit tests have been added for the entire `core` module
 66 | - ctfcli will now ask to initialize a new project if one does not exist
 67 | - Added `--hidden` to `ctf challenge install` which will deploy the challenge / challenges in a hidden state regardless of their `challenge.yml` value.
 68 | - Added `ctf challenge edit <name>` and `ctf challenge edit <name> --dockerfile` to open challenge.yml or Dockerfile for that challenge
 69 | - Added aliases under `ctf templates` and `ctf plugins` for `dir` (`path`) and for `view` (`show`)
 70 | - Progress bars for `ctf challenge deploy` / `ctf challenge install` / `ctf challenge sync`
 71 | - `ctf challenge deploy` will now deploy ALL deployable challenges if a specific challenge is not specified
 72 |   - For the SSH and Registry deployments, to facilitate this behaviour the challenge name will be automatically appended. So the host should be for example: `registry://registry.example.com/example-project` and the challenge name will be appended for a full location.
 73 | - `ctf challenge deploy` will now also automatically login to the registry with Cloud and Registry deployments.
 74 |   - For cloud deployments the instance url must be ctfd assigned (e.g. example.ctfd.io) - this is because to log-in to the registry we require a username like `admin@example.ctfd.io`. The deployment will use the access token as the password.
 75 |   - For registry deployment it will look for the `username` and `password` keys inside a `[registry]` section in the project config file.
 76 | - ctfcli will read a `LOGLEVEL` environment variable to enable DEBUG logging has been added
 77 | 
 78 | ### Fixed
 79 | 
 80 | - When syncing a challenge to a remote instance, state specified in challenge.yml will now be ignored to prevent accidental challenge leaking
 81 | - The CLI will now exit with a 0 if everything went right, and 1 if something went wrong.
 82 |   - With `install`/`sync`/`deploy` - exit code will be 1 if ANY of the challenges failed to `install`/`sync`/`deploy`.
 83 | 
 84 | ### Changed
 85 | 
 86 | - Built using poetry and `pyproject.toml`
 87 | - `python-fire` has been updated to 0.5.0
 88 | 
 89 | ### Removed
 90 | 
 91 | - Removed the `ctf challenge finalize` command
 92 | 
 93 | # 0.0.13 / 2023-07-29
 94 | 
 95 | ### Added
 96 | 
 97 | - Add env variable `CTFCLI_PLUGIN_DIR` to override the default plugin dir for development.
 98 | - Add `--directory` argument to `ctfcli challenge add`
 99 |   - Can also be called as `ctf challenge add git@github.com:repo.git directory`
100 |   - Useful for grouping challenges into separate directories like: `web/challenge1`.
101 | - `connection_info` specified in challenge.yml will be used instead of details generated by a deploy handler
102 | 
103 | ### Fixed
104 | 
105 | - Bump PyYAML version to 6.0.1
106 | 
107 | # 0.0.12 / 2023-06-25
108 | 
109 | ### Added
110 | 
111 | - Add cloud deploy for hosted CTFd instances
112 | - Add the `protocol` field in the challenge.yml spec
113 | - Further define what other deployment methods should provide & return
114 | - Add the ability to add HTTP cookies to ctfcli requests via the config file
115 | 
116 | ### Fixed
117 | 
118 | - Allow ignoring category during challenge sync
119 | 
120 | # 0.0.11 / 2022-11-09
121 | 
122 | ### Added
123 | 
124 | - Added a restart policy and container name to services deployed via ssh
125 | - Added `--yaml-path` to `ctf challenge add` to specify a specific `challenge.yml` path that will be added to the .ctf config
126 | 
127 | ### Fixed
128 | 
129 | - Fixed issue in `ctf templates list` where not all templates would be listed
130 | - Bumped version of dependencies to support Python 3.11
131 |   - Bumped `cookiecutter` to 2.1.1
132 |   - Bumped `requests` to 2.28.1
133 |   - Bumped `colorama` to 0.4.6
134 | 
135 | # 0.0.10 / 2022-03-07
136 | 
137 | ### Added
138 | 
139 | - Add support for pages in event repos
140 |   - Add the `ctf pages install` command that looks for markdown and html files with frontmatter in a special pages folder
141 | - Add `healthcheck` key in `challenge.yml` to specify a healthcheck script
142 |   - Add `ctf challenge healthcheck [challenge_name]`
143 | - Add `ssl_verify` in the `.ctf/config` file to support SSL verification disabling. `ssl_verify` can be `true` or `false` or a string (specifying the trusted SSL certificates)
144 | - Adds a `--no-git` option to `ctf init` to skip git repo creation in event folder
145 | 
146 | ### Changed
147 | 
148 | - Allow empty string in CTFd URL and CTFd access token values for `ctf init`
149 | - `ctf init` will not attempt to create git repos when the event folder is in a git repo already
150 | - `ctf init <folder>` can now be used to create the event folder instead of creating the folder beforehand
151 | 
152 | ### Fixed
153 | 
154 | - Fix issue in `ctf challenge add` where challenges weren't being added to `.ctf/config`
155 | - Fix issue where plugins couldnt be installed if only pip3 was available
156 | 
157 | # 0.0.9 / 2021-08-06
158 | 
159 | ### Added
160 | 
161 | - `ctf challenge add/update/restore` will now use git subtrees when working with git repos instead of direct cloning
162 | - `ctf challenge push [challenge]` can now be used to push local changes to the upstream challenge repo
163 | - Added challenge topics from CTFd 3.4 to the challenge.yml spec
164 | - Added challenge topics from CTFd 3.4 to the challenge `sync` and `install` commands
165 | - Added challenge connection_info from CTFd 3.4 to the challenge.yml spec
166 | - Added challenge connection_info from CTFd 3.4 to the challenge `sync` and `install` commands
167 | 
168 | # 0.0.8 / 2021-06-21
169 | 
170 | ### Added
171 | 
172 | - Added an `extra` field in challenge specification to support different CTFd challenge types
173 |   - This adds support for dynamic value challenges in CTFd > 3.3.0 (Must have commit [df27d0e7a9e336b86165d41920aa176db4ff0e06](https://github.com/CTFd/CTFd/commit/df27d0e7a9e336b86165d41920aa176db4ff0e06)).
174 | - Improved `ctf challenge lint` to catch some common mistakes in a challenge
175 | - Added an `--ignore` flag to `ctf challenge install` and `ctf challenge sync` to disable installation of certain challenge properties (e.g. flags, tags, hints, etc).
176 |   - Usage: `ctf challenge install challenge.yml --ignore=flags,tags`
177 |   - Usage: `ctf challenge install --ignore=flags,tags`
178 |   - Usage: `ctf challenge sync challenge.yml --ignore=flags,tags`
179 |   - Usage: `ctf challenge sync --ignore=flags,tags`
180 | - Automatic releases from Github to PyPI
181 | 
182 | ### Fixed
183 | 
184 | - Fix web challenge template for serve.sh
185 | - Changed all Alpine images in Dockerfiles to use Debian
186 | - Add examples or more complicated flag creation examples to challenge specification
187 | 
188 | # 0.0.7 / 2021-04-15
189 | 
190 | ### Added
191 | 
192 | - Added the following commands:
193 |   ```
194 |   ctf templates install [repo]
195 |   ctf templates uninstall [folder]
196 |   ctf templates dir
197 |   ctf templates list
198 |   ctf challenge templates
199 |   ```
200 | - Modified `ctf challenge new` to accept and search through installed third-party templates
201 | - Added a parameter to `ctf challenge update` to allow updating a single challenge
202 | - Added a login system for the default web template
203 | - Added a blank challenge template
204 | 
205 | ### Fixed
206 | 
207 | - Moved challenge template writeups into their own dedicated folder
208 | - Fixed an issue when using CTFd in a subdirectory
209 | 
210 | # 0.0.6 / 2020-10-07
211 | 
212 | ### Fixed
213 | 
214 | - Properly default the challenge state to visible during sync
215 | 
216 | # 0.0.5 / 2020-10-07
217 | 
218 | ### Added
219 | 
220 | - Added `state` parameter to control whether a challenge is visible or not
221 | - Make the `ctf challenge restore` command be able to take arguments to only restore one challenge
222 | - Add an `ctf challenge update` command to get the latest version of challenges
223 | 
224 | ### Fixed
225 | 
226 | - Fix the sync and install commands to properly install challenge files relative to the `challenge.yml` path
227 | - Update dependencies in the web challenge template
228 | 
229 | # 0.0.4 / 2020-06-07
230 | 
231 | ### Added
232 | 
233 | - `ctfcli` will now load all challenges regardless of visibility when using an
234 |   admin token. Requires CTFd v2.5.0
235 | 
236 | # 0.0.3 / 2020-04-09
237 | 
238 | ### Fixed
239 | 
240 | - `ctf init` now saves the CTFd `access_token` properly
241 | 
242 | # 0.0.2 / 2020-04-02
243 | 
244 | ### Added
245 | 
246 | - Initial release of ctfcli
247 | - `ctf init` commands
248 | - `ctf challenge` commands
249 | - `ctf config` commands
250 | - `ctf plugins` commands
251 | - README and basic example on plugins
252 | 
253 | ### Changed
254 | 
255 | - Nothing
256 | 
257 | ### Removed
258 | 
259 | - Removed initial stub release from source control
260 | 
261 | # 0.0.1 / 2020-01-01
262 | 
263 | ### Added
264 | 
265 | - Initial stub release of ctfcli
266 | 
267 | ### Changed
268 | 
269 | - Nothing
270 | 
271 | ### Removed
272 | 
273 | - Nothing
274 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | 
  2 |                                  Apache License
  3 |                            Version 2.0, January 2004
  4 |                         http://www.apache.org/licenses/
  5 | 
  6 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  7 | 
  8 |    1. Definitions.
  9 | 
 10 |       "License" shall mean the terms and conditions for use, reproduction,
 11 |       and distribution as defined by Sections 1 through 9 of this document.
 12 | 
 13 |       "Licensor" shall mean the copyright owner or entity authorized by
 14 |       the copyright owner that is granting the License.
 15 | 
 16 |       "Legal Entity" shall mean the union of the acting entity and all
 17 |       other entities that control, are controlled by, or are under common
 18 |       control with that entity. For the purposes of this definition,
 19 |       "control" means (i) the power, direct or indirect, to cause the
 20 |       direction or management of such entity, whether by contract or
 21 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 22 |       outstanding shares, or (iii) beneficial ownership of such entity.
 23 | 
 24 |       "You" (or "Your") shall mean an individual or Legal Entity
 25 |       exercising permissions granted by this License.
 26 | 
 27 |       "Source" form shall mean the preferred form for making modifications,
 28 |       including but not limited to software source code, documentation
 29 |       source, and configuration files.
 30 | 
 31 |       "Object" form shall mean any form resulting from mechanical
 32 |       transformation or translation of a Source form, including but
 33 |       not limited to compiled object code, generated documentation,
 34 |       and conversions to other media types.
 35 | 
 36 |       "Work" shall mean the work of authorship, whether in Source or
 37 |       Object form, made available under the License, as indicated by a
 38 |       copyright notice that is included in or attached to the work
 39 |       (an example is provided in the Appendix below).
 40 | 
 41 |       "Derivative Works" shall mean any work, whether in Source or Object
 42 |       form, that is based on (or derived from) the Work and for which the
 43 |       editorial revisions, annotations, elaborations, or other modifications
 44 |       represent, as a whole, an original work of authorship. For the purposes
 45 |       of this License, Derivative Works shall not include works that remain
 46 |       separable from, or merely link (or bind by name) to the interfaces of,
 47 |       the Work and Derivative Works thereof.
 48 | 
 49 |       "Contribution" shall mean any work of authorship, including
 50 |       the original version of the Work and any modifications or additions
 51 |       to that Work or Derivative Works thereof, that is intentionally
 52 |       submitted to Licensor for inclusion in the Work by the copyright owner
 53 |       or by an individual or Legal Entity authorized to submit on behalf of
 54 |       the copyright owner. For the purposes of this definition, "submitted"
 55 |       means any form of electronic, verbal, or written communication sent
 56 |       to the Licensor or its representatives, including but not limited to
 57 |       communication on electronic mailing lists, source code control systems,
 58 |       and issue tracking systems that are managed by, or on behalf of, the
 59 |       Licensor for the purpose of discussing and improving the Work, but
 60 |       excluding communication that is conspicuously marked or otherwise
 61 |       designated in writing by the copyright owner as "Not a Contribution."
 62 | 
 63 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 64 |       on behalf of whom a Contribution has been received by Licensor and
 65 |       subsequently incorporated within the Work.
 66 | 
 67 |    2. Grant of Copyright License. Subject to the terms and conditions of
 68 |       this License, each Contributor hereby grants to You a perpetual,
 69 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 70 |       copyright license to reproduce, prepare Derivative Works of,
 71 |       publicly display, publicly perform, sublicense, and distribute the
 72 |       Work and such Derivative Works in Source or Object form.
 73 | 
 74 |    3. Grant of Patent License. Subject to the terms and conditions of
 75 |       this License, each Contributor hereby grants to You a perpetual,
 76 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 77 |       (except as stated in this section) patent license to make, have made,
 78 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 79 |       where such license applies only to those patent claims licensable
 80 |       by such Contributor that are necessarily infringed by their
 81 |       Contribution(s) alone or by combination of their Contribution(s)
 82 |       with the Work to which such Contribution(s) was submitted. If You
 83 |       institute patent litigation against any entity (including a
 84 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 85 |       or a Contribution incorporated within the Work constitutes direct
 86 |       or contributory patent infringement, then any patent licenses
 87 |       granted to You under this License for that Work shall terminate
 88 |       as of the date such litigation is filed.
 89 | 
 90 |    4. Redistribution. You may reproduce and distribute copies of the
 91 |       Work or Derivative Works thereof in any medium, with or without
 92 |       modifications, and in Source or Object form, provided that You
 93 |       meet the following conditions:
 94 | 
 95 |       (a) You must give any other recipients of the Work or
 96 |           Derivative Works a copy of this License; and
 97 | 
 98 |       (b) You must cause any modified files to carry prominent notices
 99 |           stating that You changed the files; and
100 | 
101 |       (c) You must retain, in the Source form of any Derivative Works
102 |           that You distribute, all copyright, patent, trademark, and
103 |           attribution notices from the Source form of the Work,
104 |           excluding those notices that do not pertain to any part of
105 |           the Derivative Works; and
106 | 
107 |       (d) If the Work includes a "NOTICE" text file as part of its
108 |           distribution, then any Derivative Works that You distribute must
109 |           include a readable copy of the attribution notices contained
110 |           within such NOTICE file, excluding those notices that do not
111 |           pertain to any part of the Derivative Works, in at least one
112 |           of the following places: within a NOTICE text file distributed
113 |           as part of the Derivative Works; within the Source form or
114 |           documentation, if provided along with the Derivative Works; or,
115 |           within a display generated by the Derivative Works, if and
116 |           wherever such third-party notices normally appear. The contents
117 |           of the NOTICE file are for informational purposes only and
118 |           do not modify the License. You may add Your own attribution
119 |           notices within Derivative Works that You distribute, alongside
120 |           or as an addendum to the NOTICE text from the Work, provided
121 |           that such additional attribution notices cannot be construed
122 |           as modifying the License.
123 | 
124 |       You may add Your own copyright statement to Your modifications and
125 |       may provide additional or different license terms and conditions
126 |       for use, reproduction, or distribution of Your modifications, or
127 |       for any such Derivative Works as a whole, provided Your use,
128 |       reproduction, and distribution of the Work otherwise complies with
129 |       the conditions stated in this License.
130 | 
131 |    5. Submission of Contributions. Unless You explicitly state otherwise,
132 |       any Contribution intentionally submitted for inclusion in the Work
133 |       by You to the Licensor shall be under the terms and conditions of
134 |       this License, without any additional terms or conditions.
135 |       Notwithstanding the above, nothing herein shall supersede or modify
136 |       the terms of any separate license agreement you may have executed
137 |       with Licensor regarding such Contributions.
138 | 
139 |    6. Trademarks. This License does not grant permission to use the trade
140 |       names, trademarks, service marks, or product names of the Licensor,
141 |       except as required for reasonable and customary use in describing the
142 |       origin of the Work and reproducing the content of the NOTICE file.
143 | 
144 |    7. Disclaimer of Warranty. Unless required by applicable law or
145 |       agreed to in writing, Licensor provides the Work (and each
146 |       Contributor provides its Contributions) on an "AS IS" BASIS,
147 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
148 |       implied, including, without limitation, any warranties or conditions
149 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
150 |       PARTICULAR PURPOSE. You are solely responsible for determining the
151 |       appropriateness of using or redistributing the Work and assume any
152 |       risks associated with Your exercise of permissions under this License.
153 | 
154 |    8. Limitation of Liability. In no event and under no legal theory,
155 |       whether in tort (including negligence), contract, or otherwise,
156 |       unless required by applicable law (such as deliberate and grossly
157 |       negligent acts) or agreed to in writing, shall any Contributor be
158 |       liable to You for damages, including any direct, indirect, special,
159 |       incidental, or consequential damages of any character arising as a
160 |       result of this License or out of the use or inability to use the
161 |       Work (including but not limited to damages for loss of goodwill,
162 |       work stoppage, computer failure or malfunction, or any and all
163 |       other commercial damages or losses), even if such Contributor
164 |       has been advised of the possibility of such damages.
165 | 
166 |    9. Accepting Warranty or Additional Liability. While redistributing
167 |       the Work or Derivative Works thereof, You may choose to offer,
168 |       and charge a fee for, acceptance of support, warranty, indemnity,
169 |       or other liability obligations and/or rights consistent with this
170 |       License. However, in accepting such obligations, You may act only
171 |       on Your own behalf and on Your sole responsibility, not on behalf
172 |       of any other Contributor, and only if You agree to indemnify,
173 |       defend, and hold each Contributor harmless for any liability
174 |       incurred by, or claims asserted against, such Contributor by reason
175 |       of your accepting any such warranty or additional liability.
176 | 
177 |    END OF TERMS AND CONDITIONS
178 | 
179 |    APPENDIX: How to apply the Apache License to your work.
180 | 
181 |       To apply the Apache License to your work, attach the following
182 |       boilerplate notice, with the fields enclosed by brackets "[]"
183 |       replaced with your own identifying information. (Don't include
184 |       the brackets!)  The text should be enclosed in the appropriate
185 |       comment syntax for the file format. We also recommend that a
186 |       file or class name and description of purpose be included on the
187 |       same "printed page" as the copyright notice for easier
188 |       identification within third-party archives.
189 | 
190 |    Copyright 2020 CTFd LLC
191 | 
192 |    Licensed under the Apache License, Version 2.0 (the "License");
193 |    you may not use this file except in compliance with the License.
194 |    You may obtain a copy of the License at
195 | 
196 |        http://www.apache.org/licenses/LICENSE-2.0
197 | 
198 |    Unless required by applicable law or agreed to in writing, software
199 |    distributed under the License is distributed on an "AS IS" BASIS,
200 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
201 |    See the License for the specific language governing permissions and
202 |    limitations under the License.
203 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | lint:
 2 | 	black --diff .
 3 | 	isort --check .
 4 | 	ruff check .
 5 | 
 6 | format:
 7 | 	black .
 8 | 	isort .
 9 | 	ruff --fix .
10 | 
11 | test:
12 | 	pytest --cov=ctfcli tests
13 | 
14 | clean:
15 | 	rm -rf dist/
16 | 	rm -rf .ruff_cache
17 | 	rm -rf .pytest_cache
18 | 	rm -f .coverage
19 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # ctfcli
  2 | 
  3 | *ctfcli is a tool to manage Capture The Flag events and challenges.*
  4 | 
  5 | `ctfcli` provides challenge specifications and templates to make it easier to generate challenges of different categories. It also provides an integration with the [CTFd](https://github.com/CTFd/CTFd/) REST API to allow for command line uploading of challenges and integration with CI/CD build systems.
  6 | 
  7 | `ctfcli` features tab completion, a REPL interface (thanks to [Python-Fire](https://github.com/google/python-fire)) and plugin support for custom commands.
  8 | 
  9 | *WIP: ctfcli is an alpha project and changes will happen. Be sure to pin versions and read the CHANGELOG when updating.*
 10 | 
 11 | # Installation and Usage
 12 | 
 13 | ctfcli can be installed with [`pipx`](https://github.com/pypa/pipx) as an executable command:
 14 | 
 15 | `pipx install ctfcli`
 16 | 
 17 | Alternatively, you can always install it with `pip` as a python module:
 18 | 
 19 | `pip install ctfcli`
 20 | 
 21 | To install the development version of ctfcli directly from the repository you can use:
 22 | 
 23 | `pip install git+https://github.com/CTFd/ctfcli.git`
 24 | 
 25 | ## 1. Create an Event
 26 | 
 27 | Ctfcli turns the current folder into a CTF event git repo. 
 28 | It asks for the base url of the CTFd instance you're working with and an access token.
 29 | 
 30 | ```
 31 | ❯ ctf init
 32 | Please enter CTFd instance URL: https://demo.ctfd.io
 33 | Please enter CTFd Admin Access Token: d41d8cd98f00b204e9800998ecf8427e
 34 | Do you want to continue with https://demo.ctfd.io and d41d8cd98f00b204e9800998ecf8427e [Y/n]: y
 35 | Initialized empty Git repository in /Users/user/Downloads/event/.git/
 36 | ```
 37 | 
 38 | This will create the `.ctf` folder with the `config` file that will specify the URL, access token, and keep a record of
 39 | all the challenges dedicated for this event.
 40 | 
 41 | ## 2. Add challenges
 42 | 
 43 | Events are made up of challenges.
 44 | Challenges can be made from a subdirectory or pulled from another repository.
 45 | GIT-enabled challenges are pulled into the event repo, and a reference is kept in the `.ctf/config` file.
 46 | 
 47 | ```
 48 | ❯ ctf challenge add [REPO | FOLDER]
 49 | ```
 50 | 
 51 | ##### Local folder:
 52 | ```
 53 | ❯ ctf challenge add crypto/stuff
 54 | ```
 55 | 
 56 | ##### GIT repository:
 57 | ```
 58 | ❯ ctf challenge add https://github.com/challenge.git
 59 | Cloning into 'challenge'...
 60 | [...]
 61 | ```
 62 | 
 63 | ##### GIT repository to a specific subfolder:
 64 | ```
 65 | ❯ ctf challenge add https://github.com/challenge.git crypto
 66 | Cloning into 'crypto/challenge'...
 67 | [...]
 68 | ```
 69 | 
 70 | ## 3. Install challenges
 71 | 
 72 | Installing a challenge will create the challenge in your CTFd instance using the API.
 73 | 
 74 | ```
 75 | ❯ ctf challenge install [challenge]
 76 | ```
 77 | 
 78 | ```
 79 | ❯ ctf challenge install buffer_overflow
 80 | Found buffer_overflow/challenge.yml
 81 | Loaded buffer_overflow
 82 | Installing buffer_overflow
 83 | Success!
 84 | ```
 85 | 
 86 | ## 4. Sync challenges
 87 | 
 88 | Syncing a challenge will update the challenge in your CTFd instance using the API. 
 89 | Any changes made in the `challenge.yml` file will be reflected in your instance.
 90 | 
 91 | ```
 92 | ❯ ctf challenge sync [challenge]
 93 | ```
 94 | 
 95 | ```
 96 | ❯ ctf challenge sync buffer_overflow
 97 | Found buffer_overflow/challenge.yml
 98 | Loaded buffer_overflow
 99 | Syncing buffer_overflow
100 | Success!
101 | ```
102 | 
103 | ## 5. Deploy services
104 | 
105 | Deploying a challenge will automatically create the challenge service (by default in your CTFd instance).
106 | You can also use a different deployment handler to deploy the service via SSH to your own server, 
107 | or a separate docker registry.
108 | 
109 | The challenge will also be automatically installed or synced.
110 | Obtained connection info will be added to your `challenge.yml` file.
111 | ```
112 | ❯ ctf challenge deploy [challenge]
113 | ```
114 | 
115 | ```
116 | ❯ ctf challenge deploy web-1
117 | Deploying challenge service 'web-1' (web-1/challenge.yml) with CloudDeploymentHandler ...
118 | Challenge service deployed at: https://web-1-example-instance.chals.io
119 | Updating challenge 'web-1'
120 | Success!
121 | ```
122 | 
123 | ## 6. Verify challenges
124 | 
125 | Verifying a challenge will check if the local version of the challenge is the same as one installed in your CTFd instance.
126 | 
127 | ```
128 | ❯ ctf challenge verify [challenge]
129 | ```
130 | 
131 | ```
132 | ❯ ctf challenge verify buffer_overflow
133 | Verifying challenges  [------------------------------------]    0%
134 | Verifying challenges  [####################################]  100%
135 | Success! All challenges verified!
136 | Challenges in sync:
137 |  - buffer_overflow
138 | ```
139 | 
140 | ## 7. Mirror changes
141 | 
142 | Mirroring a challenge is the reverse operation to syncing.
143 | It will update the local version of the challenge with details of the one installed in your CTFd instance.
144 | It will also issue a warning if you have any remote challenges that are not tracked locally.
145 | 
146 | ```
147 | ❯ ctf challenge mirror [challenge]
148 | ```
149 | 
150 | ```
151 | ❯ ctf challenge verify buffer_overflow
152 | Mirorring challenges  [------------------------------------]    0%
153 | Mirorring challenges  [####################################]  100%
154 | Success! All challenges mirrored!
155 | ```
156 | 
157 | ## Operations on all challenges
158 | 
159 | You can perform operations on all challenges defined in your config by simply skipping the challenge parameter.
160 | 
161 | - `ctf challenge install`
162 | - `ctf challenge sync`
163 | - `ctf challenge deploy`
164 | - `ctf challenge verify`
165 | - `ctf challenge mirror`
166 | 
167 | # Challenge Templates
168 | 
169 | `ctfcli` contains pre-made challenge templates to make it faster to create CTF challenges with safe defaults.
170 | 
171 | ```
172 | ctf challenge new
173 |                 ├── binary
174 |                 ├── crypto
175 |                 ├── programming
176 |                 └── web
177 | ```
178 | 
179 | ```
180 | ❯ ctf challenge new binary
181 | /Users/user/.virtualenvs/ctfcli/lib/python3.7/site-packages/ctfcli-0.0.1-py3.7.egg/ctfcli/templates/binary/default
182 | name [Hello]: buffer_overflow
183 | 
184 | ❯ ls -1 buffer_overflow
185 | Makefile
186 | README.md
187 | WRITEUP.md
188 | challenge.yml
189 | dist/
190 | src/
191 | ```
192 | 
193 | **Contributions welcome on improving the challenge templates to make CTF challenges better for everyone!**
194 | 
195 | # Challenge Specification
196 | 
197 | `ctfcli` provides a [challenge specification](ctfcli/spec/challenge-example.yml) (`challenge.yml`) that outlines the major details of a challenge.
198 | 
199 | Every challenge generated by or processed by `ctfcli` should have a `challenge.yml` file.
200 | 
201 | The specification format has already been tested and used with CTFd in production events but comments, suggestions, and PRs are welcome on the format of `challenge.yml`.
202 | 
203 | # Plugins
204 | 
205 | `ctfcli` plugins are essentially additions to the command line interface via dynamic class modifications. See the [plugin documentation page](docs/plugins.md) for a simple example.
206 | 
207 | *`ctfcli` is an alpha project! The plugin interface is likely to change!*
208 | 
209 | # Sub-Repos as alternative to Sub-Trees
210 | 
211 | `ctfcli` manages git-based challenges by using the built-in git `subtree` mechanism. While it works most of the time, it's been proven to have disadvantages and tends to create problems and merge conflicts.  
212 | 
213 | As an alternative, we're currently experimenting with the git [`git subrepo`](https://github.com/ingydotnet/git-subrepo) extension. 
214 | This functionality can be enabled by adding a `use_subrepo = True` property to the `[config]` section inside a ctfcli project config.
215 | 
216 | Subrepo has to be installed separately, and is not backwards compatible with the default `subtree`. 
217 | Once challenges have been added by using either method, they will not work properly if you change it, and you will have to add the challenges again.
218 | 
219 | 


--------------------------------------------------------------------------------
/ctfcli/__init__.py:
--------------------------------------------------------------------------------
1 | __version__ = "0.1.4"
2 | __name__ = "ctfcli"
3 | 


--------------------------------------------------------------------------------
/ctfcli/__main__.py:
--------------------------------------------------------------------------------
  1 | import configparser
  2 | import logging
  3 | import os
  4 | import subprocess
  5 | import sys
  6 | from pathlib import Path
  7 | from typing import Optional, Union
  8 | 
  9 | import click
 10 | import fire
 11 | 
 12 | from ctfcli.cli.challenges import ChallengeCommand
 13 | from ctfcli.cli.config import ConfigCommand
 14 | from ctfcli.cli.instance import InstanceCommand
 15 | from ctfcli.cli.media import MediaCommand
 16 | from ctfcli.cli.pages import PagesCommand
 17 | from ctfcli.cli.plugins import PluginsCommand
 18 | from ctfcli.cli.templates import TemplatesCommand
 19 | from ctfcli.core.exceptions import (
 20 |     MissingAPIKey,
 21 |     MissingInstanceURL,
 22 |     ProjectNotInitialized,
 23 | )
 24 | from ctfcli.core.plugins import load_plugins
 25 | from ctfcli.utils.git import check_if_dir_is_inside_git_repo
 26 | 
 27 | # Init logging
 28 | logging.basicConfig(level=os.environ.get("LOGLEVEL", "INFO").upper())
 29 | 
 30 | log = logging.getLogger("ctfcli.main")
 31 | 
 32 | 
 33 | class CTFCLI:
 34 |     @staticmethod
 35 |     def init(
 36 |         directory: Optional[Union[str, os.PathLike]] = None,
 37 |         no_git: bool = False,
 38 |         no_commit: bool = False,
 39 |     ):
 40 |         log.debug(f"init: (directory={directory}, no_git={no_git}, no_commit={no_commit})")
 41 |         project_path = Path.cwd()
 42 | 
 43 |         # Create our project directory if requested
 44 |         if directory:
 45 |             project_path = Path(directory)
 46 | 
 47 |             if not project_path.exists():
 48 |                 project_path.mkdir(parents=True)
 49 |                 click.secho(f"Created empty directory in {project_path.absolute()}", fg="green")
 50 | 
 51 |         # Avoid colliding with existing .ctf directory
 52 |         if (project_path / ".ctf").exists():
 53 |             click.secho(".ctf/ folder already exists. Aborting!", fg="red")
 54 |             return
 55 | 
 56 |         log.debug(f"project_path: {project_path}")
 57 | 
 58 |         # Create .ctf directory
 59 |         (project_path / ".ctf").mkdir()
 60 | 
 61 |         # Get variables from user
 62 |         ctf_url = click.prompt("Please enter CTFd instance URL", default="", show_default=False)
 63 | 
 64 |         ctf_token = click.prompt("Please enter CTFd Admin Access Token", default="", show_default=False)
 65 | 
 66 |         # Confirm information with user
 67 |         if not click.confirm(f"Do you want to continue with {ctf_url} and {ctf_token}", default=True):
 68 |             click.echo("Aborted!")
 69 |             return
 70 | 
 71 |         # Create initial .ctf/config file
 72 |         config = configparser.ConfigParser()
 73 |         config["config"] = {"url": ctf_url, "access_token": ctf_token}
 74 |         config["challenges"] = {}
 75 |         with (project_path / ".ctf" / "config").open(mode="a+") as config_file:
 76 |             config.write(config_file)
 77 | 
 78 |         # if git init is to be skipped we can return
 79 |         if no_git:
 80 |             click.secho("Skipping git init.", fg="yellow")
 81 |             return
 82 | 
 83 |         # also skip git init if git is already initialized
 84 |         if check_if_dir_is_inside_git_repo(cwd=project_path):
 85 |             click.secho("Already in a git repo. Skipping git init.", fg="yellow")
 86 | 
 87 |             # is git commit is to be skipped we can return
 88 |             if no_commit:
 89 |                 click.secho("Skipping git commit.", fg="yellow")
 90 |                 return
 91 | 
 92 |             subprocess.call(["git", "add", ".ctf/config"], cwd=project_path)
 93 |             subprocess.call(["git", "commit", "-m", "init ctfcli project"], cwd=project_path)
 94 |             return
 95 | 
 96 |         # Create a git repo in the project folder
 97 |         click.secho(f"Creating a git repo in {project_path}", fg="green")
 98 |         subprocess.call(["git", "init", str(project_path)])
 99 | 
100 |         if no_commit:
101 |             click.secho("Skipping git commit.", fg="yellow")
102 |             return
103 | 
104 |         subprocess.call(["git", "add", ".ctf/config"], cwd=project_path)
105 |         subprocess.call(["git", "commit", "-m", "init ctfcli project"], cwd=project_path)
106 | 
107 |     def config(self):
108 |         return COMMANDS.get("config")
109 | 
110 |     def instance(self):
111 |         return COMMANDS.get("instance")
112 | 
113 |     def challenge(self):
114 |         return COMMANDS.get("challenge")
115 | 
116 |     def pages(self):
117 |         return COMMANDS.get("pages")
118 | 
119 |     def media(self):
120 |         return COMMANDS.get("media")
121 | 
122 |     def plugins(self):
123 |         return COMMANDS.get("plugins")
124 | 
125 |     def templates(self):
126 |         return COMMANDS.get("templates")
127 | 
128 | 
129 | COMMANDS = {
130 |     "challenge": ChallengeCommand(),
131 |     "config": ConfigCommand(),
132 |     "pages": PagesCommand(),
133 |     "plugins": PluginsCommand(),
134 |     "templates": TemplatesCommand(),
135 |     "instance": InstanceCommand(),
136 |     "media": MediaCommand(),
137 |     "cli": CTFCLI(),
138 | }
139 | 
140 | 
141 | def main():
142 |     # Load plugins
143 |     load_plugins(COMMANDS)
144 | 
145 |     # Load CLI
146 |     try:
147 |         # if the command returns an int, then we serialize it as none to prevent fire from printing it
148 |         # (this does not change the actual return value, so it's still good to use as an exit code)
149 |         # everything else is returned as is, so fire can print help messages
150 |         ret = fire.Fire(COMMANDS["cli"], serialize=lambda r: None if isinstance(r, int) else r)
151 | 
152 |         if isinstance(ret, int):
153 |             sys.exit(ret)
154 | 
155 |     except MissingInstanceURL as e:
156 |         click.secho(e, fg="red")
157 |         sys.exit(1)
158 | 
159 |     except MissingAPIKey as e:
160 |         click.secho(e, fg="red")
161 |         sys.exit(1)
162 | 
163 |     except ProjectNotInitialized:
164 |         if click.confirm(
165 |             "Outside of a ctfcli project, would you like to start a new project in this directory?",
166 |             default=False,
167 |         ):
168 |             CTFCLI.init()
169 |     except KeyboardInterrupt:
170 |         click.secho("\n[Ctrl-C] Aborting.", fg="red")
171 |         sys.exit(2)
172 | 
173 | 
174 | if __name__ == "__main__":
175 |     main()
176 | 


--------------------------------------------------------------------------------
/ctfcli/cli/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CTFd/ctfcli/c5abdd499bc9112c6832e047aa1c77b3052de05f/ctfcli/cli/__init__.py


--------------------------------------------------------------------------------
/ctfcli/cli/config.py:
--------------------------------------------------------------------------------
 1 | import logging
 2 | import os
 3 | import subprocess
 4 | 
 5 | import click
 6 | from pygments import highlight
 7 | from pygments.formatters import TerminalFormatter
 8 | from pygments.lexers import IniLexer, JsonLexer
 9 | 
10 | from ctfcli.core.config import Config
11 | 
12 | log = logging.getLogger("ctfcli.cli.config")
13 | 
14 | 
15 | class ConfigCommand:
16 |     def edit(self) -> int:
17 |         log.debug("edit")
18 |         editor = os.getenv("EDITOR", "vi")
19 | 
20 |         log.debug(f"call(['{editor}', '{Config.get_config_path()}'])")
21 |         subprocess.call([editor, Config.get_config_path()])
22 |         return 0
23 | 
24 |     def path(self) -> int:
25 |         log.debug("path")
26 |         click.echo(Config.get_config_path())
27 |         return 0
28 | 
29 |     def show(self, color=True, json=False) -> int:
30 |         # alias for the view command
31 |         log.debug(f"show (color={color}, json={json})")
32 |         return self.view(color=color, json=json)
33 | 
34 |     def view(self, color=True, json=False) -> int:
35 |         log.debug(f"view (color={color}, json={json})")
36 |         config = Config()
37 | 
38 |         if json:
39 |             config_json = config.as_json(pretty=True)
40 | 
41 |             if color:
42 |                 click.echo(highlight(config_json, JsonLexer(), TerminalFormatter()))
43 |                 return 0
44 | 
45 |             click.echo(config_json)
46 |             return 0
47 | 
48 |         with open(config.get_config_path(), "r") as config_file:
49 |             config_ini = config_file.read()
50 | 
51 |             if color:
52 |                 click.echo(highlight(config_ini, IniLexer(), TerminalFormatter()))
53 |                 return 0
54 | 
55 |             click.echo(config_ini)
56 |             return 0
57 | 


--------------------------------------------------------------------------------
/ctfcli/cli/instance.py:
--------------------------------------------------------------------------------
 1 | import logging
 2 | 
 3 | import click
 4 | 
 5 | from ctfcli.core.config import Config
 6 | from ctfcli.core.instance.config import ServerConfig
 7 | 
 8 | log = logging.getLogger("ctfcli.cli.instance")
 9 | 
10 | 
11 | class ConfigCommand:
12 |     def get(self, key):
13 |         """Get the value of a specific remote instance config key"""
14 |         log.debug(f"ConfigCommand.get: ({key=})")
15 |         return ServerConfig.get(key=key)
16 | 
17 |     def set(self, key, value):
18 |         """Set the value of a specific remote instance config key"""
19 |         log.debug(f"ConfigCommand.set: ({key=})")
20 |         ServerConfig.set(key=key, value=value)
21 |         click.secho(f"Successfully set '{key}' to '{value}'", fg="green")
22 | 
23 |     def pull(self):
24 |         """Copy remote instance configuration values to local config"""
25 |         log.debug("ConfigCommand.pull")
26 |         server_configs = ServerConfig.getall()
27 | 
28 |         config = Config()
29 |         if config.config.has_section("instance") is False:
30 |             config.config.add_section("instance")
31 | 
32 |         for k, v in server_configs.items():
33 |             # We always store as a string because the CTFd Configs model is a string
34 |             if v == "None":
35 |                 v = "null"
36 |             config.config.set("instance", k, str(v))
37 | 
38 |         with open(config.config_path, "w+") as f:
39 |             config.write(f)
40 | 
41 |         click.secho("Successfully pulled configuration", fg="green")
42 | 
43 |     def push(self):
44 |         """Save local instance configuration values to remote CTFd instance"""
45 |         log.debug("ConfigCommand.push")
46 |         config = Config()
47 |         if config.config.has_section("instance") is False:
48 |             config.config.add_section("instance")
49 | 
50 |         configs = {}
51 |         for k in config["instance"]:
52 |             v = config["instance"][k]
53 |             if v == "null":
54 |                 v = None
55 |             configs[k] = v
56 | 
57 |         failed_configs = ServerConfig.setall(configs=configs)
58 |         for f in failed_configs:
59 |             click.secho(f"Failed to push config {f}", fg="red")
60 | 
61 |         if not failed_configs:
62 |             click.secho("Successfully pushed config", fg="green")
63 |         else:
64 |             return 1
65 | 
66 | 
67 | class InstanceCommand:
68 |     def config(self):
69 |         return ConfigCommand
70 | 


--------------------------------------------------------------------------------
/ctfcli/cli/media.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | 
 3 | import click
 4 | 
 5 | from ctfcli.core.api import API
 6 | from ctfcli.core.config import Config
 7 | 
 8 | 
 9 | class MediaCommand:
10 |     def add(self, path):
11 |         """Add local media file to config file and remote instance"""
12 |         config = Config()
13 |         if config.config.has_section("media") is False:
14 |             config.config.add_section("media")
15 | 
16 |         api = API()
17 | 
18 |         new_file = ("file", open(path, mode="rb"))
19 |         filename = os.path.basename(path)
20 |         location = f"media/{filename}"
21 |         file_payload = {
22 |             "type": "page",
23 |             "location": location,
24 |         }
25 | 
26 |         # Specifically use data= here to send multipart/form-data
27 |         r = api.post("/api/v1/files", files=[new_file], data=file_payload)
28 |         r.raise_for_status()
29 |         resp = r.json()
30 |         server_location = resp["data"][0]["location"]
31 | 
32 |         # Close the file handle
33 |         new_file[1].close()
34 | 
35 |         config.config.set("media", location, f"/files/{server_location}")
36 | 
37 |         with open(config.config_path, "w+") as f:
38 |             config.write(f)
39 | 
40 |     def rm(self, path):
41 |         """Remove local media file from remote server and local config"""
42 |         config = Config()
43 |         api = API()
44 | 
45 |         local_location = config["media"][path]
46 | 
47 |         remote_files = api.get("/api/v1/files?type=page").json()["data"]
48 |         for remote_file in remote_files:
49 |             if f"/files/{remote_file['location']}" == local_location:
50 |                 # Delete file from server
51 |                 r = api.delete(f"/api/v1/files/{remote_file['id']}")
52 |                 r.raise_for_status()
53 | 
54 |                 # Update local config file
55 |                 del config["media"][path]
56 |                 with open(config.config_path, "w+") as f:
57 |                     config.write(f)
58 | 
59 |     def url(self, path):
60 |         """Get server URL for a file key"""
61 |         config = Config()
62 |         api = API()
63 | 
64 |         if config.config.has_section("media") is False:
65 |             config.config.add_section("media")
66 | 
67 |         try:
68 |             location = config["media"][path]
69 |         except KeyError:
70 |             click.secho(f"Could not locate local media '{path}'", fg="red")
71 |             return 1
72 | 
73 |         remote_files = api.get("/api/v1/files?type=page").json()["data"]
74 |         for remote_file in remote_files:
75 |             if f"/files/{remote_file['location']}" == location:
76 |                 base_url = config["config"]["url"]
77 |                 base_url = base_url.rstrip("/")
78 |                 return f"{base_url}{location}"
79 |         click.secho(f"Could not locate remote media '{path}'", fg="red")
80 |         return 1
81 | 


--------------------------------------------------------------------------------
/ctfcli/cli/pages.py:
--------------------------------------------------------------------------------
 1 | import logging
 2 | from typing import Optional
 3 | 
 4 | import click
 5 | 
 6 | from ctfcli.core.exceptions import PageException
 7 | from ctfcli.core.page import Page
 8 | 
 9 | log = logging.getLogger("ctfcli.cli.pages")
10 | 
11 | 
12 | class PagesCommand:
13 |     # _page_operation is a wrapper to calling Page methods, to avoid code duplication, it will:
14 |     # - log the operation
15 |     # - perform it on the page object, with given arguments
16 |     # - handle the possible exception and echo it out with click
17 |     # - return right exit code
18 |     def _page_operation(self, page: Page, operation: str, *args, **kwargs) -> int:
19 |         if operation not in ["push", "pull", "sync"]:
20 |             raise ValueError
21 | 
22 |         page_operation = getattr(page, operation)
23 |         try:
24 |             log.debug(f"{operation}: {page}")
25 |             page_operation(*args, **kwargs)
26 |             click.secho(f"Successfully {operation}ed page '{page.page_file_path}'", fg="green")
27 |             return 0
28 |         except PageException as e:
29 |             click.secho(str(e), fg="red")
30 |             return 1
31 | 
32 |     def push(self, page: Optional[str] = None) -> int:
33 |         pages = Page.get_local_pages()
34 | 
35 |         if page:
36 |             page_object = next(
37 |                 (page_obj for page_obj in pages if page == page_obj.page_file_path),
38 |                 None,
39 |             )
40 |             if page_object:
41 |                 return self._page_operation(page_object, "push")
42 | 
43 |             click.secho(f"Could not find page '{page}'", fg="red")
44 |             return 1
45 | 
46 |         return_code = 0
47 |         for page_object in pages:
48 |             status = self._page_operation(page_object, "push")
49 | 
50 |             if status == 1:
51 |                 return_code = 1
52 | 
53 |         return return_code
54 | 
55 |     def sync(self, page: Optional[str] = None) -> int:
56 |         pages = Page.get_local_pages()
57 | 
58 |         if page:
59 |             page_object = next(
60 |                 (page_obj for page_obj in pages if page == page_obj.page_file_path),
61 |                 None,
62 |             )
63 |             if page_object:
64 |                 return self._page_operation(page_object, "sync")
65 | 
66 |             click.secho(f"Could not find page '{page}'", fg="red")
67 |             return 1
68 | 
69 |         return_code = 0
70 |         for page_object in pages:
71 |             status = self._page_operation(page_object, "sync")
72 | 
73 |             if status == 1:
74 |                 return_code = 1
75 | 
76 |         return return_code
77 | 
78 |     def pull(self, route: Optional[str] = None, force=False) -> int:
79 |         if route:
80 |             page_id = Page.get_remote_page_id(route)
81 |             if not page_id:
82 |                 click.secho(f"Could not find page with route '{route}'", fg="red")
83 |                 return 1
84 | 
85 |             page_object = Page(page_id=page_id)
86 |             return self._page_operation(page_object, "pull", overwrite=force)
87 | 
88 |         return_code = 0
89 |         pages = Page.get_remote_pages()
90 |         for page_object in pages:
91 |             status = self._page_operation(page_object, "pull", overwrite=force)
92 |             if status == 1:
93 |                 return_code = 1
94 | 
95 |         return return_code
96 | 


--------------------------------------------------------------------------------
/ctfcli/cli/plugins.py:
--------------------------------------------------------------------------------
  1 | import logging
  2 | import shutil
  3 | import subprocess
  4 | from pathlib import Path
  5 | 
  6 | import click
  7 | 
  8 | from ctfcli.core.config import Config
  9 | 
 10 | log = logging.getLogger("ctfcli.cli.plugins")
 11 | 
 12 | 
 13 | class PluginsCommand:
 14 |     @staticmethod
 15 |     def install(plugin_url: str) -> int:
 16 |         log.debug(f"install: {plugin_url}")
 17 | 
 18 |         plugins_path = Config.get_plugins_path()
 19 |         if not plugin_url.endswith(".git"):
 20 |             click.secho(
 21 |                 "Can only install plugins from git repositories - " f"{plugin_url} does not end with .git",
 22 |                 fg="red",
 23 |             )
 24 |             return 1
 25 | 
 26 |         installed_plugin_path = plugins_path / Path(plugin_url).stem
 27 |         log.debug(f"call(['git', 'clone', '{plugin_url}', '{installed_plugin_path}'])")
 28 |         git_clone = subprocess.call(["git", "clone", plugin_url, installed_plugin_path])
 29 | 
 30 |         if git_clone != 0:
 31 |             click.secho(
 32 |                 "Failed to clone the plugin repository. Please check git output above.",
 33 |                 fg="red",
 34 |             )
 35 |             return 1
 36 | 
 37 |         requirements_path = installed_plugin_path / "requirements.txt"
 38 |         if requirements_path.exists():
 39 |             pip = shutil.which("pip")
 40 |             pip3 = shutil.which("pip3")
 41 | 
 42 |             if pip is None and pip3 is None:
 43 |                 click.secho("Neither pip nor pip3 was found, is it in the PATH?", fg="red")
 44 |                 return 1
 45 | 
 46 |             if pip is None:
 47 |                 pip = pip3
 48 | 
 49 |             log.debug(f"call(['{pip}', 'install', '-r', '{requirements_path}'])")
 50 |             pip_install = subprocess.call([pip, "install", "-r", requirements_path])
 51 | 
 52 |             if pip_install != 0:
 53 |                 click.secho(
 54 |                     "Failed to install plugin requirements. Please check pip output above.",
 55 |                     fg="red",
 56 |                 )
 57 |                 return 1
 58 | 
 59 |         return 0
 60 | 
 61 |     @staticmethod
 62 |     def uninstall(plugin_name: str) -> int:
 63 |         log.debug(f"uninstall: {plugin_name}")
 64 | 
 65 |         plugins_path = Config.get_plugins_path()
 66 |         plugin_path = plugins_path / plugin_name
 67 | 
 68 |         if not plugin_path.exists():
 69 |             click.secho(f"Could not find plugin {plugin_name} in {plugins_path}", fg="red")
 70 |             return 1
 71 | 
 72 |         shutil.rmtree(plugin_path)
 73 |         return 0
 74 | 
 75 |     @staticmethod
 76 |     def list() -> int:
 77 |         log.debug("list")
 78 | 
 79 |         installed_plugins = sorted(Config.get_plugins_path().iterdir())
 80 |         if len(installed_plugins) == 0:
 81 |             click.secho("Found no installed plugins", fg="blue")
 82 |             return 0
 83 | 
 84 |         click.secho("List of installed plugins:", fg="blue")
 85 |         for plugin in installed_plugins:
 86 |             click.echo(f" - {plugin}")
 87 | 
 88 |         return 0
 89 | 
 90 |     @staticmethod
 91 |     def dir() -> int:
 92 |         log.debug("dir")
 93 |         return PluginsCommand.path()
 94 | 
 95 |     @staticmethod
 96 |     def path() -> int:
 97 |         log.debug("path")
 98 |         click.echo(Config.get_plugins_path())
 99 |         return 0
100 | 


--------------------------------------------------------------------------------
/ctfcli/cli/templates.py:
--------------------------------------------------------------------------------
 1 | import logging
 2 | import shutil
 3 | import subprocess
 4 | from glob import glob
 5 | from pathlib import Path
 6 | 
 7 | import click
 8 | 
 9 | from ctfcli.core.config import Config
10 | 
11 | log = logging.getLogger("ctfcli.cli.templates")
12 | 
13 | 
14 | class TemplatesCommand:
15 |     @staticmethod
16 |     def install(template_url: str) -> int:
17 |         log.debug(f"install: {template_url}")
18 | 
19 |         templates_path = Config.get_templates_path()
20 |         if not template_url.endswith(".git"):
21 |             click.secho(
22 |                 "Can only install templates from git repositories - " f"{template_url} does not end with .git",
23 |                 fg="red",
24 |             )
25 |             return 1
26 | 
27 |         installed_template_path = templates_path / Path(template_url).stem
28 |         git_clone = subprocess.call(["git", "clone", template_url, installed_template_path])
29 | 
30 |         if git_clone != 0:
31 |             click.secho(
32 |                 "Failed to clone the template repository. Please check git output above.",
33 |                 fg="red",
34 |             )
35 |             return 1
36 | 
37 |         return 0
38 | 
39 |     @staticmethod
40 |     def uninstall(template_name: str) -> int:
41 |         log.debug(f"uninstall: {template_name}")
42 | 
43 |         templates_path = Config.get_templates_path()
44 |         template_path = templates_path / template_name
45 | 
46 |         if not template_path.exists():
47 |             click.secho(f"Could not find template {template_name} in {templates_path}", fg="red")
48 |             return 1
49 | 
50 |         shutil.rmtree(template_path)
51 |         return 0
52 | 
53 |     @staticmethod
54 |     def list() -> int:
55 |         log.debug("list")
56 | 
57 |         base_path = Config.get_base_path()
58 |         templates_path = Config.get_templates_path()
59 | 
60 |         # Echo built-in templates
61 |         built_in_templates = base_path / "templates"
62 | 
63 |         click.secho("List of built-in templates:", fg="blue")
64 |         for template in built_in_templates.iterdir():
65 |             click.echo(f" - {template.relative_to(built_in_templates)}")
66 | 
67 |         # echo a new line separator
68 |         click.echo()
69 | 
70 |         installed_templates = glob(f"{templates_path}/**/*/cookiecutter.json", recursive=True)
71 |         if len(installed_templates) == 0:
72 |             click.secho("Found no user-installed templates", fg="blue")
73 |             return 0
74 | 
75 |         click.secho("List of user-installed templates:", fg="blue")
76 |         for template in installed_templates:
77 |             # Remove prefix of templates_path (+1 for last slash) and remove suffix of /cookiecutter.json
78 |             template_path = str(template)[len(str(templates_path)) + 1 : -len("/cookiecutter.json")]
79 |             click.echo(f" - {template_path}")
80 | 
81 |         return 0
82 | 
83 |     @staticmethod
84 |     def dir() -> int:
85 |         log.debug("dir")
86 |         return TemplatesCommand.path()
87 | 
88 |     @staticmethod
89 |     def path() -> int:
90 |         log.debug("path")
91 |         click.echo(Config.get_templates_path())
92 |         return 0
93 | 


--------------------------------------------------------------------------------
/ctfcli/core/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CTFd/ctfcli/c5abdd499bc9112c6832e047aa1c77b3052de05f/ctfcli/core/__init__.py


--------------------------------------------------------------------------------
/ctfcli/core/api.py:
--------------------------------------------------------------------------------
 1 | from urllib.parse import urljoin
 2 | 
 3 | from requests import Session
 4 | 
 5 | from ctfcli.core.config import Config
 6 | from ctfcli.core.exceptions import MissingAPIKey, MissingInstanceURL
 7 | 
 8 | 
 9 | class API(Session):
10 |     def __init__(self):
11 |         config = Config()
12 | 
13 |         # Load required configuration values
14 |         try:
15 |             self.url = config["config"]["url"]
16 |         except KeyError:
17 |             raise MissingInstanceURL()
18 | 
19 |         try:
20 |             self.access_token = config["config"]["access_token"]
21 |         except KeyError:
22 |             raise MissingAPIKey()
23 | 
24 |         # Handle SSL verification disabling
25 |         try:
26 |             # Get an ssl_verify config. Default to True if it doesn't exist
27 |             ssl_verify = config["config"].getboolean("ssl_verify", True)
28 |         except ValueError:
29 |             # If we didn't a proper boolean value we should load it as a string
30 |             # https://requests.kennethreitz.org/en/master/user/advanced/#ssl-cert-verification
31 |             ssl_verify = config["config"].get("ssl_verify")
32 | 
33 |         super(API, self).__init__()
34 | 
35 |         # Strip out ending slashes and append a singular one, so we generate
36 |         # clean base URLs for both main deployments and subdir deployments
37 |         self.prefix_url = self.url.rstrip("/") + "/"
38 | 
39 |         # Handle SSL verification
40 |         self.verify = ssl_verify
41 | 
42 |         # Handle Authorization
43 |         self.headers.update({"Authorization": f"Token {self.access_token}"})
44 | 
45 |         # Handle cookies section in config
46 |         if "cookies" in config:
47 |             self.cookies.update(dict(config["cookies"]))
48 | 
49 |     def request(self, method, url, *args, **kwargs):
50 |         # Strip out the preceding / so that urljoin creates the right url
51 |         # considering the appended / on the prefix_url
52 |         url = urljoin(self.prefix_url, url.lstrip("/"))
53 | 
54 |         # if data= is present, do not modify the content-type
55 |         if kwargs.get("data", None) is not None:
56 |             return super(API, self).request(method, url, *args, **kwargs)
57 | 
58 |         # otherwise set the content-type to application/json for all API requests
59 |         # modify the headers here instead of using self.headers because we don't want to
60 |         # override the multipart/form-data case above
61 |         if kwargs.get("headers", None) is None:
62 |             kwargs["headers"] = {}
63 | 
64 |         kwargs["headers"]["Content-Type"] = "application/json"
65 |         return super(API, self).request(method, url, *args, **kwargs)
66 | 


--------------------------------------------------------------------------------
/ctfcli/core/config.py:
--------------------------------------------------------------------------------
  1 | import configparser
  2 | import json
  3 | import os
  4 | from pathlib import Path
  5 | 
  6 | import appdirs
  7 | 
  8 | from ctfcli import __name__ as pkg_name
  9 | from ctfcli.core.exceptions import ProjectNotInitialized
 10 | 
 11 | 
 12 | class Config:
 13 |     _env_vars = {
 14 |         "CTFCLI_ACCESS_TOKEN": "access_token",
 15 |         "CTFCLI_URL": "url",
 16 |     }
 17 | 
 18 |     def __init__(self):
 19 |         self.base_path = self.get_base_path()
 20 |         self.project_path = self.get_project_path()
 21 |         self.config_path = self.project_path / ".ctf" / "config"
 22 |         self.data_path = self.get_data_path()
 23 |         self.templates_path = self.get_templates_path()
 24 |         self.pages_path = self.get_pages_path()
 25 |         self.plugins_path = self.get_plugins_path()
 26 | 
 27 |         parser = configparser.ConfigParser()
 28 |         parser.optionxform = str
 29 |         parser.read(self.config_path)
 30 | 
 31 |         self.config = parser
 32 |         self.challenges = dict(self.config["challenges"])
 33 | 
 34 |         # Load environment variables
 35 |         self._env_overrides()
 36 | 
 37 |     def _env_overrides(self):
 38 |         """
 39 |         For each environment variable specified in _env_vars, check if it exists
 40 |         and if so, add it to the config under the "config" section.
 41 |         """
 42 |         for env_var, config_key in self._env_vars.items():
 43 |             env_value = os.getenv(env_var)
 44 |             if not env_value:
 45 |                 continue
 46 | 
 47 |             if not self.config.has_section("config"):
 48 |                 self.config.add_section("config")
 49 | 
 50 |             self.config["config"][config_key] = env_value
 51 | 
 52 |     def __getitem__(self, key):
 53 |         return self.config[key]
 54 | 
 55 |     def __contains__(self, key):
 56 |         return key in self.config
 57 | 
 58 |     def write(self, file_handle):
 59 |         return self.config.write(file_handle)
 60 | 
 61 |     def as_json(self, pretty=False) -> str:
 62 |         data = {}
 63 |         for section in self.config.sections():
 64 |             data[section] = {}
 65 |             for k, v in self.config.items(section):
 66 |                 data[section][k] = v
 67 | 
 68 |         if pretty:
 69 |             return json.dumps(data, sort_keys=True, indent=4)
 70 | 
 71 |         return json.dumps(data)
 72 | 
 73 |     @staticmethod
 74 |     def get_project_path() -> Path:
 75 |         pwd = Path.cwd()
 76 |         while pwd != Path("/"):
 77 |             config = pwd / ".ctf" / "config"
 78 |             if config.is_file():
 79 |                 return pwd
 80 |             pwd = pwd.parent
 81 | 
 82 |         raise ProjectNotInitialized
 83 | 
 84 |     @staticmethod
 85 |     def get_config_path() -> Path:
 86 |         return Config.get_project_path() / ".ctf" / "config"
 87 | 
 88 |     @staticmethod
 89 |     def get_base_path() -> Path:
 90 |         return Path(__file__).parent.parent
 91 | 
 92 |     @staticmethod
 93 |     def get_data_path() -> Path:
 94 |         return Path(appdirs.user_data_dir(appname=pkg_name))
 95 | 
 96 |     @staticmethod
 97 |     def get_pages_path() -> Path:
 98 |         pages_path = Config.get_project_path() / "pages"
 99 | 
100 |         if not pages_path.exists():
101 |             pages_path.mkdir()
102 | 
103 |         return pages_path
104 | 
105 |     @staticmethod
106 |     def get_templates_path() -> Path:
107 |         templates_path = Config.get_data_path() / "templates"
108 | 
109 |         if not templates_path.exists():
110 |             templates_path.mkdir(parents=True)
111 | 
112 |         return templates_path
113 | 
114 |     @staticmethod
115 |     def get_plugins_path() -> Path:
116 |         if os.getenv("CTFCLI_PLUGIN_PATH"):
117 |             plugins_path = Config._get_custom_plugin_path()
118 |         else:
119 |             plugins_path = Config.get_data_path() / "plugins"
120 | 
121 |         if not plugins_path.exists():
122 |             plugins_path.mkdir(parents=True)
123 | 
124 |         return plugins_path
125 | 
126 |     @staticmethod
127 |     def _get_custom_plugin_path() -> Path:
128 |         # Assumes CTFCLI_PLUGIN_PATH is present
129 |         custom_plugins_path = Path(os.getenv("CTFCLI_PLUGIN_PATH"))
130 | 
131 |         if custom_plugins_path.is_absolute():
132 |             return custom_plugins_path
133 | 
134 |         # If path is relative, assume it's to ctfcli base_path (development convenience)
135 |         return Config.get_base_path() / custom_plugins_path
136 | 


--------------------------------------------------------------------------------
/ctfcli/core/deployment/__init__.py:
--------------------------------------------------------------------------------
 1 | from typing import Dict, Type
 2 | 
 3 | from ctfcli.core.deployment.base import DeploymentHandler
 4 | from ctfcli.core.deployment.cloud import CloudDeploymentHandler
 5 | from ctfcli.core.deployment.registry import RegistryDeploymentHandler
 6 | from ctfcli.core.deployment.ssh import SSHDeploymentHandler
 7 | 
 8 | DEPLOYMENT_HANDLERS: Dict[str, Type[DeploymentHandler]] = {
 9 |     "cloud": CloudDeploymentHandler,
10 |     "ssh": SSHDeploymentHandler,
11 |     "registry": RegistryDeploymentHandler,
12 | }
13 | 
14 | 
15 | def get_deployment_handler(name: str) -> Type[DeploymentHandler]:
16 |     return DEPLOYMENT_HANDLERS[name]
17 | 
18 | 
19 | def register_deployment_handler(name: str, handler: Type[DeploymentHandler]):
20 |     DEPLOYMENT_HANDLERS[name] = handler
21 | 


--------------------------------------------------------------------------------
/ctfcli/core/deployment/base.py:
--------------------------------------------------------------------------------
 1 | from typing import Optional
 2 | 
 3 | from ctfcli.core.challenge import Challenge
 4 | 
 5 | 
 6 | class DeploymentResult:
 7 |     def __init__(
 8 |         self,
 9 |         success: bool,
10 |         domain: Optional[str] = None,
11 |         port: Optional[str] = None,
12 |         connection_info: Optional[str] = None,
13 |     ):
14 |         self.success = success
15 |         self.domain = domain
16 |         self.port = port
17 |         self.connection_info = connection_info
18 | 
19 | 
20 | class DeploymentHandler:
21 |     def __init__(self, challenge: Challenge, host: Optional[str] = None, protocol: Optional[str] = None):
22 |         self.challenge = challenge
23 |         self.host = host if host else challenge.get("host", None)
24 |         self.protocol = protocol if protocol else challenge.get("protocol", None)
25 | 
26 |     def deploy(self, *args, **kwargs) -> DeploymentResult:
27 |         raise NotImplementedError
28 | 


--------------------------------------------------------------------------------
/ctfcli/core/deployment/cloud.py:
--------------------------------------------------------------------------------
  1 | import logging
  2 | import subprocess
  3 | import time
  4 | from typing import Dict, Optional
  5 | from urllib.parse import urlparse
  6 | 
  7 | import click
  8 | from slugify import slugify
  9 | 
 10 | from ctfcli.core.api import API
 11 | from ctfcli.core.config import Config
 12 | from ctfcli.core.deployment.base import DeploymentHandler, DeploymentResult
 13 | 
 14 | log = logging.getLogger("ctfcli.core.deployment.cloud")
 15 | 
 16 | 
 17 | class CloudDeploymentHandler(DeploymentHandler):
 18 |     def __init__(self, *args, **kwargs):
 19 |         super(CloudDeploymentHandler, self).__init__(*args, **kwargs)
 20 | 
 21 |         self.api = API()
 22 |         self.config = Config()
 23 | 
 24 |         # Do not fail here if challenge does not provide an image
 25 |         # rather return a failed deployment result during deploy
 26 |         if self.challenge.get("image"):
 27 |             self.image_name = self.challenge.image.basename
 28 | 
 29 |     def deploy(self, skip_login=False, *args, **kwargs) -> DeploymentResult:
 30 |         # Check whether challenge defines image
 31 |         if not self.challenge.get("image"):
 32 |             click.secho("Challenge does not define an image to deploy", fg="red")
 33 |             return DeploymentResult(False)
 34 | 
 35 |         # Check whether instance supports cloud deployments
 36 |         check = self.api.get("/api/v1/images")
 37 |         if not check.ok:
 38 |             click.secho("Target instance does not support cloud deployments", fg="red")
 39 |             return DeploymentResult(False)
 40 | 
 41 |         # Get or create Image in CTFd
 42 |         image_data = self._get_or_create_image()
 43 | 
 44 |         # Build or Pull / Update the configured image
 45 |         if self.challenge.image.built:
 46 |             if not self.challenge.image.pull():
 47 |                 click.secho("Could not pull the image. Please check docker output above.", fg="red")
 48 |                 return DeploymentResult(False)
 49 |         else:
 50 |             if not self.challenge.image.build():
 51 |                 click.secho("Could not build the image. Please check docker output above.", fg="red")
 52 |                 return DeploymentResult(False)
 53 | 
 54 |         if skip_login:
 55 |             click.secho(
 56 |                 "Skipping registry login because of --skip-login. Make sure you are logged in to the registry.",
 57 |                 fg="yellow",
 58 |             )
 59 |         else:
 60 |             login_result = self._registry_login()
 61 | 
 62 |             if not login_result:
 63 |                 click.secho(
 64 |                     "Could not log in to the registry. Please check your access token and instance URL", fg="red"
 65 |                 )
 66 |                 return DeploymentResult(False)
 67 | 
 68 |         push_result = self.challenge.image.push(image_data["location"])
 69 |         if not push_result:
 70 |             click.secho("Could not push image to the registry.", fg="red")
 71 | 
 72 |             if skip_login:
 73 |                 click.secho(
 74 |                     "Remember that you need to manually login to the docker registry when using --skip-login",
 75 |                     fg="yellow",
 76 |                 )
 77 | 
 78 |             return DeploymentResult(False)
 79 | 
 80 |         # Get or create Service in CTFd
 81 |         service_data = self._get_or_create_service(image_data["location"])
 82 | 
 83 |         deployed_service_data = self._await_service_deployment(service_data)
 84 |         if not deployed_service_data:
 85 |             return DeploymentResult(False)
 86 | 
 87 |         # Expose TCP port if configured
 88 |         if self.protocol == "tcp":
 89 |             self.api.patch(f"/api/v1/services/{deployed_service_data['id']}", json={"expose": True}).raise_for_status()
 90 |             deployed_service_data = self.api.get(f"/api/v1/services/{deployed_service_data['id']}").json()["data"]
 91 | 
 92 |         connection_info = self._get_connection_info(
 93 |             hostname=deployed_service_data["hostname"],
 94 |             tcp_hostname=deployed_service_data.get("tcp_hostname"),
 95 |             tcp_port=deployed_service_data.get("tcp_port"),
 96 |         )
 97 | 
 98 |         return DeploymentResult(True, connection_info=connection_info)
 99 | 
100 |     def _get_or_create_image(self):
101 |         # Check if image already exists
102 |         existing_images = self.api.get("/api/v1/images").json()["data"]
103 |         for image_data in existing_images:
104 |             if image_data["location"].endswith(self.image_name):
105 |                 return image_data
106 | 
107 |         # Create the image if it doesn't exist
108 |         return self.api.post("/api/v1/images", json={"name": self.image_name}).json()["data"]
109 | 
110 |     def _get_or_create_service(self, image_location: str):
111 |         existing_services = self.api.get("/api/v1/services").json()["data"]
112 |         for service_data in existing_services:
113 |             if service_data["name"] == self.image_name:
114 |                 # Update the existing service image information
115 |                 self.api.patch(
116 |                     f"/api/v1/services/{service_data['id']}",
117 |                     json={"image": image_location},
118 |                 ).raise_for_status()
119 |                 return self.api.get(f"/api/v1/services/{service_data['id']}").json()["data"]
120 | 
121 |         # Create the service if it doesn't exist
122 |         image_name_slug = slugify(self.image_name)
123 |         return self.api.post("/api/v1/services", json={"name": image_name_slug, "image": image_location}).json()["data"]
124 | 
125 |     def _await_service_deployment(self, service_data, interval=10, timeout=180) -> Optional[Dict]:
126 |         service_id = service_data["id"]
127 | 
128 |         base_timeout = timeout
129 |         i = 0
130 |         while service_data.get("hostname") is None and timeout > 0:
131 |             click.secho(
132 |                 f"Awaiting service deployment [{i * interval}/{base_timeout}s]",
133 |                 fg="yellow",
134 |             )
135 |             service_data = self.api.get(f"/api/v1/services/{service_id}").json()["data"]
136 | 
137 |             i += 1
138 |             timeout -= interval
139 |             time.sleep(interval)
140 | 
141 |         if timeout == 0:
142 |             click.secho("Timeout awaiting challenge deployment", fg="red")
143 |             return
144 | 
145 |         return service_data
146 | 
147 |     def _registry_login(self, registry: str = "registry.ctfd.io") -> bool:
148 |         r = self.api.get("/api/v1/users/me")
149 |         r.raise_for_status()
150 |         data = r.json()
151 | 
152 |         if not data["success"]:
153 |             return False
154 | 
155 |         # build registry username: admin@instance.ctfd.io
156 |         username = data["data"]["name"]
157 |         hostname = urlparse(self.api.prefix_url).hostname
158 | 
159 |         # require instance url to be ctfd assigned for now
160 |         # later this could use dig to resolve a cname record
161 |         if not hostname or not str(hostname).endswith(".ctfd.io"):
162 |             click.secho(
163 |                 "Instance URL is not a CTFd assigned URL. Either use the CTFd assigned domain name, "
164 |                 "or login to the registry manually and deploy with --skip-login",
165 |                 fg="red",
166 |             )
167 |             return False
168 | 
169 |         docker_login = f"{username}@{hostname}"
170 |         docker_password = self.api.access_token.encode()
171 |         docker_login_command = [
172 |             "docker",
173 |             "login",
174 |             "-u",
175 |             docker_login,
176 |             "--password-stdin",
177 |             registry,
178 |         ]
179 | 
180 |         log.debug(f"call({docker_login_command}, stderr=subprocess.PIPE, input=docker_password)")
181 |         login_response = subprocess.check_output(docker_login_command, input=docker_password, stderr=subprocess.PIPE)
182 | 
183 |         if b"Login Succeeded" in login_response:
184 |             return True
185 | 
186 |         return False
187 | 
188 |     def _get_connection_info(
189 |         self,
190 |         hostname: str,
191 |         tcp_hostname: Optional[str] = None,
192 |         tcp_port: Optional[str] = None,
193 |     ) -> str:
194 |         # if protocol is http(s) - return an URL
195 |         if self.protocol and self.protocol.startswith("http"):
196 |             # cloud deployments always deploy on https
197 |             return f"https://{hostname}"
198 | 
199 |         # if protocol is tcp, and connection details are provided - return netcat connection string
200 |         if self.protocol and self.protocol == "tcp" and tcp_hostname and tcp_port:
201 |             return f"nc {tcp_hostname} {tcp_port}"
202 | 
203 |         # Otherwise return plain hostname
204 |         return hostname
205 | 


--------------------------------------------------------------------------------
/ctfcli/core/deployment/registry.py:
--------------------------------------------------------------------------------
  1 | import logging
  2 | import subprocess
  3 | from urllib.parse import urlparse
  4 | 
  5 | import click
  6 | 
  7 | from ctfcli.core.config import Config
  8 | from ctfcli.core.deployment.base import DeploymentHandler, DeploymentResult
  9 | 
 10 | log = logging.getLogger("ctfcli.core.deployment.registry")
 11 | 
 12 | 
 13 | class RegistryDeploymentHandler(DeploymentHandler):
 14 |     def deploy(self, skip_login=False, *args, **kwargs) -> DeploymentResult:
 15 |         config = Config()
 16 | 
 17 |         # Check whether challenge defines image
 18 |         if not self.challenge.get("image"):
 19 |             click.secho("Challenge does not define an image to deploy", fg="red")
 20 |             return DeploymentResult(False)
 21 | 
 22 |         if not self.host:
 23 |             click.secho(
 24 |                 "No host provided for the deployment. Use --host, or define host in the challenge.yml file", fg="red"
 25 |             )
 26 |             return DeploymentResult(False)
 27 | 
 28 |         # resolve a location for the image push
 29 |         # e.g. registry.example.com/test-project/challenge-image-name
 30 |         # challenge image name is appended to the host provided for the deployment
 31 |         host_url = urlparse(self.host)
 32 |         location = f"{host_url.netloc}{host_url.path.rstrip('/')}/{self.challenge.image.basename}"
 33 | 
 34 |         if skip_login:
 35 |             click.secho(
 36 |                 "Skipping registry login because of --skip-login. Make sure you are logged in to the registry.",
 37 |                 fg="yellow",
 38 |             )
 39 |         else:
 40 |             if "registry" not in config or not config["registry"]:
 41 |                 click.secho("Config does not provide a registry section.", fg="red")
 42 |                 return DeploymentResult(False)
 43 | 
 44 |             registry_username = config["registry"].get("username")
 45 |             registry_password = config["registry"].get("password")
 46 |             if not registry_username or not registry_password:
 47 |                 click.secho("Config is missing credentials for the registry.", fg="red")
 48 |                 return DeploymentResult(False)
 49 | 
 50 |             login_result = self._registry_login(
 51 |                 registry_username,
 52 |                 registry_password,
 53 |                 host_url.netloc,
 54 |             )
 55 | 
 56 |             if not login_result:
 57 |                 click.secho("Could not log in to the registry. Please check your configured credentials.", fg="red")
 58 |                 return DeploymentResult(False)
 59 | 
 60 |         if self.challenge.image.built:
 61 |             if not self.challenge.image.pull():
 62 |                 click.secho("Could not pull the image. Please check docker output above.", fg="red")
 63 |                 return DeploymentResult(False)
 64 |         else:
 65 |             if not self.challenge.image.build():
 66 |                 click.secho("Could not build the image. Please check docker output above.", fg="red")
 67 |                 return DeploymentResult(False)
 68 | 
 69 |         push_result = self.challenge.image.push(location)
 70 |         if not push_result:
 71 |             click.secho("Could not push image to the registry. Please check docker output above.", fg="red")
 72 | 
 73 |             if skip_login:
 74 |                 click.secho(
 75 |                     "Remember that you need to manually login to the docker registry when using --skip-login",
 76 |                     fg="yellow",
 77 |                 )
 78 | 
 79 |             return DeploymentResult(False)
 80 | 
 81 |         # In this deployment result we can't really provide more data such as the connection info, as we don't know
 82 |         # where and how the service is deployed - only that it's pushed to a registry
 83 |         return DeploymentResult(True)
 84 | 
 85 |     def _registry_login(self, username: str, password: str, registry: str):
 86 |         docker_login_command = [
 87 |             "docker",
 88 |             "login",
 89 |             "-u",
 90 |             username,
 91 |             "--password-stdin",
 92 |             registry,
 93 |         ]
 94 | 
 95 |         try:
 96 |             log.debug(
 97 |                 f"call({docker_login_command}, input=password, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)"
 98 |             )
 99 |             subprocess.run(
100 |                 docker_login_command, input=password.encode(), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
101 |             )
102 |         except subprocess.CalledProcessError:
103 |             return False
104 |         return True
105 | 


--------------------------------------------------------------------------------
/ctfcli/core/deployment/ssh.py:
--------------------------------------------------------------------------------
  1 | import subprocess
  2 | from pathlib import Path
  3 | from urllib.parse import urlparse
  4 | 
  5 | import click
  6 | 
  7 | from ctfcli.core.deployment.base import DeploymentHandler, DeploymentResult
  8 | 
  9 | 
 10 | class SSHDeploymentHandler(DeploymentHandler):
 11 |     def deploy(self, *args, **kwargs) -> DeploymentResult:
 12 |         if not self.challenge.get("image"):
 13 |             click.secho("Challenge does not define an image to deploy", fg="red")
 14 |             return DeploymentResult(False)
 15 | 
 16 |         if not self.host:
 17 |             click.secho(
 18 |                 "No host provided for the deployment. Use --host, or define host in the challenge.yml file", fg="red"
 19 |             )
 20 |             return DeploymentResult(False)
 21 | 
 22 |         if self.challenge.image.built:
 23 |             if not self.challenge.image.pull():
 24 |                 click.secho("Could not pull the image. Please check docker output above.", fg="red")
 25 |                 return DeploymentResult(False)
 26 |         else:
 27 |             if not self.challenge.image.build():
 28 |                 click.secho("Could not build the image. Please check docker output above.", fg="red")
 29 |                 return DeploymentResult(False)
 30 | 
 31 |         image_name = self.challenge.image.name
 32 |         image_basename = self.challenge.image.basename
 33 |         image_export = self.challenge.image.export()
 34 |         if not image_export:
 35 |             click.secho("Could not export the image. Please check docker output above.", fg="red")
 36 |             return DeploymentResult(False)
 37 | 
 38 |         image_export_path = Path(image_export)
 39 |         host_url = urlparse(self.host)
 40 |         target_path = host_url.path or "/tmp"
 41 |         target_file = f"{target_path}/{image_export_path.name}"
 42 | 
 43 |         exposed_port = self.challenge.image.get_exposed_port()
 44 |         if not exposed_port:
 45 |             click.secho("Could not resolve a port to expose. Make sure your Dockerfile EXPOSE's a port.", fg="red")
 46 |             return DeploymentResult(False)
 47 | 
 48 |         target_hostname = host_url.netloc[host_url.netloc.find("@") + 1 :]
 49 |         try:
 50 |             subprocess.run(["scp", image_export_path, f"{host_url.netloc}:{target_file}"])
 51 |             subprocess.run(
 52 |                 [
 53 |                     "ssh",
 54 |                     host_url.netloc,
 55 |                     f"docker load -i {target_file} && rm {target_file}",
 56 |                 ]
 57 |             )
 58 |             subprocess.run(
 59 |                 [
 60 |                     "ssh",
 61 |                     host_url.netloc,
 62 |                     f"docker stop {image_basename} 2>/dev/null; docker rm {image_basename} 2>/dev/null",
 63 |                 ]
 64 |             )
 65 |             subprocess.run(
 66 |                 [
 67 |                     "ssh",
 68 |                     host_url.netloc,
 69 |                     f"docker run -d -p{exposed_port}:{exposed_port} --name {image_basename} "
 70 |                     f"--restart always {image_name}",
 71 |                 ]
 72 |             )
 73 | 
 74 |         except subprocess.CalledProcessError as e:
 75 |             click.secho("Failed to deploy image!", fg="red")
 76 |             click.secho(str(e), fg="red")
 77 |             return DeploymentResult(False)
 78 | 
 79 |         image_export_path.unlink()
 80 | 
 81 |         connection_info = self._get_connection_info(target_hostname, exposed_port)
 82 |         return DeploymentResult(True, target_hostname, exposed_port, connection_info)
 83 | 
 84 |     def _get_connection_info(self, hostname: str, port: int) -> str:
 85 |         # if protocol is http(s) - return an URL
 86 |         if self.protocol and self.protocol.startswith("http"):
 87 |             # if port is the default for http or https don't include a port
 88 |             if port == 80 and self.protocol == "http":
 89 |                 return f"http://{hostname}"
 90 | 
 91 |             if port == 443 and self.protocol == "https":
 92 |                 return f"https://{hostname}"
 93 | 
 94 |             return f"{self.protocol}://{hostname}:{port}"
 95 | 
 96 |         # if protocol is tcp, and connection details are provided - return netcat connection string
 97 |         if self.protocol and self.protocol == "tcp":
 98 |             return f"nc {hostname} {port}"
 99 | 
100 |         # Otherwise return plain hostname
101 |         return hostname
102 | 


--------------------------------------------------------------------------------
/ctfcli/core/exceptions.py:
--------------------------------------------------------------------------------
 1 | from typing import Dict, List
 2 | 
 3 | import click
 4 | 
 5 | 
 6 | class MissingAPIKey(Exception):
 7 |     def __str__(self):
 8 |         return (
 9 |             "Missing API key. "
10 |             "Please set the API key in your configuration file or set the CTFCLI_ACCESS_TOKEN environment variable."
11 |         )
12 | 
13 | 
14 | class MissingInstanceURL(Exception):
15 |     def __str__(self):
16 |         return (
17 |             "Missing CTFd instance URL. "
18 |             "Please set the instance URL in your configuration file or set the CTFCLI_URL environment variable."
19 |         )
20 | 
21 | 
22 | class ProjectNotInitialized(Exception):
23 |     pass
24 | 
25 | 
26 | class ChallengeException(Exception):
27 |     pass
28 | 
29 | 
30 | class InvalidChallengeDefinition(ChallengeException):
31 |     pass
32 | 
33 | 
34 | class InvalidChallengeFile(ChallengeException):
35 |     pass
36 | 
37 | 
38 | class RemoteChallengeNotFound(ChallengeException):
39 |     pass
40 | 
41 | 
42 | class LintException(Exception):
43 |     def __init__(self, *args, issues: Dict[str, List[str]] = None):
44 |         self.issues = issues if issues else {}
45 |         super(LintException, self).__init__(*args)
46 | 
47 |     def print_summary(self):
48 |         for category, issues in self.issues.items():
49 |             if len(issues) > 0:
50 |                 click.secho(f"{category.capitalize()}:", fg="yellow")
51 | 
52 |                 prefix = " - " if category != "hadolint" else ""
53 |                 for issue in issues:
54 |                     click.echo(f"{prefix}{issue}")
55 | 
56 |                 if category != "hadolint":
57 |                     click.echo()
58 | 
59 | 
60 | class PageException(Exception):
61 |     pass
62 | 
63 | 
64 | class InvalidPageFormat(PageException):
65 |     pass
66 | 
67 | 
68 | class InvalidPageConfiguration(PageException):
69 |     pass
70 | 
71 | 
72 | class IllegalPageOperation(PageException):
73 |     pass
74 | 
75 | 
76 | class InstanceConfigException(Exception):
77 |     pass
78 | 


--------------------------------------------------------------------------------
/ctfcli/core/image.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | import subprocess
 3 | import tempfile
 4 | from os import PathLike
 5 | from pathlib import Path
 6 | from typing import Optional, Union
 7 | 
 8 | 
 9 | class Image:
10 |     def __init__(self, name: str, build_path: Optional[Union[str, PathLike]] = None):
11 |         # name can be either a new name to assign or an existing image name
12 |         self.name = name
13 | 
14 |         # if the image is a remote image (eg. ghcr.io/.../...), extract the basename
15 |         self.basename = name
16 |         if "/" in self.name or ":" in self.name:
17 |             self.basename = self.name.split(":")[0].split("/")[-1]
18 | 
19 |         self.built = True
20 | 
21 |         # if the image provides a build path, assume it is not built yet
22 |         if build_path:
23 |             self.build_path = Path(build_path)
24 |             self.built = False
25 | 
26 |     def build(self) -> Optional[str]:
27 |         docker_build = subprocess.call(
28 |             ["docker", "build", "--load", "-t", self.name, "."], cwd=self.build_path.absolute()
29 |         )
30 |         if docker_build != 0:
31 |             return
32 | 
33 |         self.built = True
34 |         return self.name
35 | 
36 |     def pull(self) -> Optional[str]:
37 |         docker_pull = subprocess.call(["docker", "pull", self.name])
38 |         if docker_pull != 0:
39 |             return
40 | 
41 |         return self.name
42 | 
43 |     def push(self, location: str) -> Optional[str]:
44 |         if not self.built:
45 |             self.build()
46 | 
47 |         docker_tag = subprocess.call(["docker", "tag", self.name, location])
48 |         docker_push = subprocess.call(["docker", "push", location])
49 | 
50 |         if any(r != 0 for r in [docker_tag, docker_push]):
51 |             return
52 | 
53 |         return location
54 | 
55 |     def export(self) -> Optional[str]:
56 |         if not self.built:
57 |             self.build()
58 | 
59 |         image_tar = tempfile.NamedTemporaryFile(delete=False, suffix=f"_{self.basename}.docker.tar")
60 |         docker_save = subprocess.call(["docker", "save", "--output", image_tar.name, self.name])
61 | 
62 |         if docker_save != 0:
63 |             return
64 | 
65 |         return image_tar.name
66 | 
67 |     def get_exposed_port(self) -> Optional[str]:
68 |         if not self.built:
69 |             self.build()
70 | 
71 |         try:
72 |             docker_output = subprocess.check_output(
73 |                 ["docker", "inspect", "--format={{json .Config.ExposedPorts}}", self.name]
74 |             )
75 |         except subprocess.CalledProcessError:
76 |             return
77 | 
78 |         ports_data = json.loads(docker_output)
79 |         if ports_data:
80 |             ports = list(ports_data.keys())
81 | 
82 |             if ports:
83 |                 # Split '2323/tcp'
84 |                 return ports[0].split("/")[0]
85 | 


--------------------------------------------------------------------------------
/ctfcli/core/instance/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CTFd/ctfcli/c5abdd499bc9112c6832e047aa1c77b3052de05f/ctfcli/core/instance/__init__.py


--------------------------------------------------------------------------------
/ctfcli/core/instance/config.py:
--------------------------------------------------------------------------------
 1 | from typing import List
 2 | 
 3 | from ctfcli.core.api import API
 4 | from ctfcli.core.exceptions import InstanceConfigException
 5 | 
 6 | 
 7 | class ServerConfig:
 8 |     @staticmethod
 9 |     def get(key: str) -> str:
10 |         api = API()
11 |         resp = api.get(f"/api/v1/configs/{key}")
12 |         if resp.ok is False:
13 |             raise InstanceConfigException(
14 |                 f"Could not get config {key=} because '{resp.content}' with {resp.status_code}"
15 |             )
16 |         resp = resp.json()
17 |         return resp["data"]["value"]
18 | 
19 |     @staticmethod
20 |     def set(key: str, value: str) -> bool:
21 |         api = API()
22 |         data = {
23 |             "value": value,
24 |         }
25 |         resp = api.patch(f"/api/v1/configs/{key}", json=data)
26 |         if resp.ok is False:
27 |             raise InstanceConfigException(
28 |                 f"Could not get config {key=} because '{resp.content}' with {resp.status_code}"
29 |             )
30 |         resp = resp.json()
31 | 
32 |         return resp["success"]
33 | 
34 |     @staticmethod
35 |     def getall():
36 |         api = API()
37 |         resp = api.get("/api/v1/configs")
38 |         if resp.ok is False:
39 |             raise InstanceConfigException(f"Could not get configs because '{resp.content}' with {resp.status_code}")
40 |         resp = resp.json()
41 |         configs = resp["data"]
42 | 
43 |         config = {}
44 |         for c in configs:
45 |             # Ignore alembic_version configs as they are managed by plugins
46 |             if c["key"].endswith("alembic_version") is False:
47 |                 config[c["key"]] = c["value"]
48 | 
49 |         # Not much point in saving internal configs
50 |         config.pop("ctf_version", None)
51 |         config.pop("version_latest", None)
52 |         config.pop("next_update_check", None)
53 |         config.pop("setup", None)
54 | 
55 |         return config
56 | 
57 |     @staticmethod
58 |     def setall(configs) -> List[str]:
59 |         failed = []
60 |         for k, v in configs.items():
61 |             try:
62 |                 ServerConfig.set(key=k, value=v)
63 |             except InstanceConfigException:
64 |                 failed.append(k)
65 |         return failed
66 | 


--------------------------------------------------------------------------------
/ctfcli/core/media.py:
--------------------------------------------------------------------------------
 1 | from ctfcli.core.config import Config
 2 | from ctfcli.utils.tools import safe_format
 3 | 
 4 | 
 5 | class Media:
 6 |     @staticmethod
 7 |     def replace_placeholders(content: str) -> str:
 8 |         config = Config()
 9 |         try:
10 |             section = config["media"]
11 |         except KeyError:
12 |             section = []
13 |         for m in section:
14 |             content = safe_format(content, items={m: config["media"][m]})
15 |         return content
16 | 


--------------------------------------------------------------------------------
/ctfcli/core/page.py:
--------------------------------------------------------------------------------
  1 | from os import PathLike
  2 | from pathlib import Path
  3 | from typing import Dict, List, Optional, Union
  4 | 
  5 | try:
  6 |     from typing import Self
  7 | except ImportError:
  8 |     from typing_extensions import Self
  9 | 
 10 | import click
 11 | import frontmatter
 12 | 
 13 | from ctfcli.core.api import API
 14 | from ctfcli.core.config import Config
 15 | from ctfcli.core.exceptions import (
 16 |     IllegalPageOperation,
 17 |     InvalidPageConfiguration,
 18 |     InvalidPageFormat,
 19 | )
 20 | from ctfcli.core.media import Media
 21 | 
 22 | PAGE_FORMATS = {
 23 |     ".md": "markdown",
 24 |     ".html": "html",
 25 |     ".htm": "html",
 26 | }
 27 | 
 28 | 
 29 | # Note:
 30 | # This class cannot delete pages yet - which can lead to expected, but perhaps unintuitive behavior with sync
 31 | # When changing a route of a page, it will not be possible to sync it as we will not be able to determine an existing
 32 | # page to update (that is done with the route).
 33 | # The page can be pushed, but that will just create another page at the new route - which can then be reflected locally
 34 | # by using pull. The old page has to be deleted manually or hidden with sync and hidden: true
 35 | 
 36 | 
 37 | class Page:
 38 |     _remote_pages: Optional[List[Self]] = None
 39 |     _remote_page_ids: Optional[Dict[str, int]] = None
 40 | 
 41 |     def __init__(self, page_path: Optional[Union[str, PathLike]] = None, page_id: Optional[int] = None):
 42 |         # single page object can only be created as either local or remote at the moment
 43 |         # this can be changed later to allow a merge-like behavior
 44 |         if not page_path and not page_id or page_path and page_id:
 45 |             raise InvalidPageConfiguration
 46 | 
 47 |         self.api = API()
 48 | 
 49 |         if page_id:
 50 |             # if page is remote - it can only be used for downloading
 51 |             self.page_id = page_id
 52 |             page_data = self._get_data_by_id()
 53 |             self.format = page_data["format"]
 54 | 
 55 |             # if page is remote we have to infer a local file name
 56 |             # default to route.ext which also works for nesting: nested/route.ext
 57 |             self.page_file_path = f"{page_data['route']}{self.get_format_extension(self.format)}"
 58 |         else:
 59 |             # if page is local - it can be used for sync, upload and download (with overwrite)
 60 |             self.page_path = Path(page_path)
 61 |             page_data = self._get_data_by_path()
 62 |             self.format = self.get_format(self.page_path.suffix)
 63 | 
 64 |             # check if page is also remote, so that we can potentially sync
 65 |             remote_page_id = self.get_remote_page_id(page_data["route"])
 66 |             if remote_page_id:
 67 |                 self.page_id = remote_page_id
 68 | 
 69 |             # if page is local we can know the page file path
 70 |             # which should be output as relative to the pages directory
 71 |             self.page_file_path = str(self.page_path.relative_to(Config.get_pages_path()))
 72 | 
 73 |         self.route = page_data["route"]
 74 |         self.title = page_data["title"]
 75 |         self.content = page_data["content"]
 76 |         self.is_draft = bool(page_data.get("draft", False))
 77 |         self.is_hidden = bool(page_data.get("hidden", False))
 78 |         self.is_auth_required = bool(page_data.get("auth_required", False))
 79 | 
 80 |     def __str__(self):
 81 |         return self.page_file_path
 82 | 
 83 |     def _get_data_by_path(self) -> Optional[Dict]:
 84 |         if not self.page_path.exists():
 85 |             return
 86 | 
 87 |         with open(self.page_path, "r") as page_file:
 88 |             page_data = frontmatter.load(page_file)
 89 |             content = Media.replace_placeholders(page_data.content)
 90 |             return {**page_data.metadata, "content": content}
 91 | 
 92 |     def _get_data_by_id(self) -> Optional[Dict]:
 93 |         r = self.api.get(f"/api/v1/pages/{self.page_id}")
 94 | 
 95 |         if not r.ok:
 96 |             return
 97 | 
 98 |         return r.json()["data"]
 99 | 
100 |     def as_dict(self):
101 |         return {
102 |             "route": self.route,
103 |             "title": self.title,
104 |             "content": self.content,
105 |             "draft": self.is_draft,
106 |             "hidden": self.is_hidden,
107 |             "auth_required": self.is_auth_required,
108 |             "format": self.format,
109 |         }
110 | 
111 |     def as_frontmatter_post(self) -> frontmatter.Post:
112 |         metadata = {
113 |             "route": self.route,
114 |             "title": self.title,
115 |             "draft": self.is_draft,
116 |             "hidden": self.is_hidden,
117 |             "auth_required": self.is_auth_required,
118 |         }
119 |         return frontmatter.Post(self.content, **metadata)
120 | 
121 |     def sync(self):
122 |         # sync / update remote copy with local state
123 |         if not getattr(self, "page_id", None):
124 |             raise IllegalPageOperation(
125 |                 f"Cannot sync page '{self.page_file_path}' - remote version does not exists. Use push first."
126 |             )
127 | 
128 |         if not getattr(self, "page_path", None):
129 |             raise IllegalPageOperation(
130 |                 f"Cannot sync page '{self.page_file_path}' - local version does not exists. Use pull first."
131 |             )
132 | 
133 |         r = self.api.patch(f"/api/v1/pages/{self.page_id}", json=self.as_dict())
134 |         r.raise_for_status()
135 | 
136 |     def pull(self, overwrite=False):
137 |         # download / create local copy of a remote page
138 |         # download without overwrite is useful only for initial pull
139 |         if not getattr(self, "page_id", None):
140 |             raise IllegalPageOperation(f"Cannot pull page '{self.page_file_path}' - remote version does not exists.")
141 | 
142 |         page_path = Config.get_pages_path() / self.page_file_path
143 | 
144 |         # make sure all necessary directories exist
145 |         page_path.parent.mkdir(parents=True, exist_ok=True)
146 | 
147 |         if page_path.is_file():
148 |             if not overwrite:
149 |                 raise IllegalPageOperation(f"Cannot pull page '{self.page_file_path}' - file already exists.")
150 | 
151 |             click.secho(f"Overwriting page file '{self.page_file_path}'", fg="yellow")
152 | 
153 |         with open(page_path, "wb+") as page_file:
154 |             frontmatter.dump(self.as_frontmatter_post(), page_file)
155 | 
156 |     def push(self):
157 |         # upload / create remote copy of a local page
158 |         if getattr(self, "page_id", None):
159 |             raise IllegalPageOperation(
160 |                 f"Cannot push page '{self.page_file_path}' - remote version exists. Use sync instead."
161 |             )
162 | 
163 |         r = self.api.post("/api/v1/pages", json=self.as_dict())
164 |         r.raise_for_status()
165 | 
166 |         self.page_id = r.json()["data"]["id"]
167 | 
168 |     @staticmethod
169 |     def get_format(ext) -> str:
170 |         if ext not in PAGE_FORMATS:
171 |             raise InvalidPageFormat
172 | 
173 |         return PAGE_FORMATS[ext]
174 | 
175 |     @staticmethod
176 |     def get_format_extension(fmt) -> str:
177 |         if fmt is None:
178 |             return ".md"
179 |         for supported_ext, supported_fmt in PAGE_FORMATS.items():
180 |             if fmt == supported_fmt:
181 |                 return supported_ext
182 | 
183 |         raise InvalidPageFormat
184 | 
185 |     @classmethod
186 |     def get_remote_pages(cls) -> List[Self]:
187 |         # if we find a saved list of remote pages we can use it
188 |         if cls._remote_pages:
189 |             return cls._remote_pages
190 | 
191 |         api = API()
192 |         installed_pages = api.get("/api/v1/pages").json()["data"]
193 | 
194 |         pages = []
195 |         for page in installed_pages:
196 |             pages.append(Page(page_id=page["id"]))
197 | 
198 |         # save remote pages for reuse
199 |         cls._remote_pages = pages
200 |         return pages
201 | 
202 |     @classmethod
203 |     def get_remote_page_id(cls, route: str) -> Optional[int]:
204 |         # if we find a saved cache, and the route has a page_id associated - we can return it
205 |         if cls._remote_page_ids and route in cls._remote_page_ids:
206 |             return cls._remote_page_ids[route]
207 | 
208 |         # if we find a saved list of remote pages instead, we can also use it
209 |         if cls._remote_pages:
210 |             for page in cls._remote_pages:
211 |                 if route == page.route:
212 |                     return page.page_id
213 | 
214 |         # otherwise we just take the result of listing all pages to search for the id
215 |         # and build the lookup cache for further use
216 |         api = API()
217 |         remote_pages = api.get("/api/v1/pages").json()["data"]
218 | 
219 |         remote_page_ids = {}
220 |         for page in remote_pages:
221 |             remote_page_ids[page["route"]] = page["id"]
222 | 
223 |         cls._remote_page_ids = remote_page_ids
224 | 
225 |         # finally return the page id from the lookup dict, if the route has been found
226 |         return cls._remote_page_ids.get(route, None)
227 | 
228 |     @classmethod
229 |     def get_local_pages(cls) -> List[Self]:
230 |         config = Config()
231 |         pages_dir = config.get_pages_path()
232 | 
233 |         page_files = []
234 |         for supported_ext in PAGE_FORMATS.keys():
235 |             page_files.extend(list(pages_dir.glob(f"**/*{supported_ext}")))
236 | 
237 |         pages = []
238 |         for page_path in page_files:
239 |             pages.append(Page(page_path=page_path))
240 | 
241 |         return pages
242 | 


--------------------------------------------------------------------------------
/ctfcli/core/plugins.py:
--------------------------------------------------------------------------------
 1 | import importlib
 2 | import logging
 3 | import sys
 4 | from typing import Dict
 5 | 
 6 | from ctfcli.core.config import Config
 7 | 
 8 | log = logging.getLogger("ctfcli.core.plugins")
 9 | 
10 | 
11 | def load_plugins(commands: Dict):
12 |     plugins_path = Config.get_plugins_path()
13 |     sys.path.insert(0, str(plugins_path.absolute()))
14 | 
15 |     for plugin in sorted(plugins_path.iterdir()):
16 |         if plugin.name.startswith("_") or plugin.name.startswith("."):
17 |             continue
18 | 
19 |         plugin_path = plugins_path / plugin / "__init__.py"
20 | 
21 |         log.debug(f"Loading plugin '{plugin}' from '{plugin_path}'")
22 | 
23 |         loaded = importlib.import_module(plugin.stem)
24 |         loaded.load(commands)
25 | 
26 |     sys.path.remove(str(plugins_path.absolute()))
27 | 


--------------------------------------------------------------------------------
/ctfcli/spec/challenge-example.yml:
--------------------------------------------------------------------------------
  1 | # This file represents the base specification of your challenge. It is used by
  2 | # other tools to install and deploy your challenge.
  3 | 
  4 | # Required sections
  5 | name: "{{cookiecutter.name}}"
  6 | author: "author"
  7 | category: category
  8 | description: This is a sample description
  9 | attribution: Written by [author](https://ctfd.io)
 10 | value: 100
 11 | type: standard
 12 | 
 13 | # The extra field provides additional fields for data during the install/sync commands/
 14 | # Fields in extra can be used to supply additional information for other challenge types
 15 | # For example the follow extra field is for dynamic challenges. To use these following
 16 | # extra fields, set the type to "dynamic" and uncomment the "extra" section below
 17 | # extra:
 18 | #     initial: 500
 19 | #     decay: 100
 20 | #     minimum: 50
 21 | 
 22 | # Settings used for Dockerfile deployment
 23 | # If not used, remove or set to null
 24 | # If you have a Dockerfile set to .
 25 | # If you have an imaged hosted on Docker set to the image url (e.g. python/3.8:latest, registry.gitlab.com/python/3.8:latest)
 26 | # Follow Docker best practices and assign a tag
 27 | image: null
 28 | 
 29 | # Specify a protocol that should be used to connect to the running image
 30 | # For example if the image is a website you can specify http or https
 31 | # Otherwise you can specify tcp
 32 | protocol: null
 33 | 
 34 | # Specify a host to deploy the challenge onto.
 35 | # The currently supported URI schemes are ssh:// and registry://
 36 | # ssh is an ssh URI where the above image will be copied to and deployed (e.g. ssh://root@123.123.123.123)
 37 | # registry is a Docker registry tag (e.g registry://registry.example.com/test/image)
 38 | # host can also be specified during the deploy process: `ctf challenge deploy challenge --host=ssh://root@123.123.123.123`
 39 | host: null
 40 | 
 41 | # Optional settings
 42 | 
 43 | # connection_info is used to provide a link, hostname, or instructions on how to connect to a challenge
 44 | connection_info: nc hostname 12345
 45 | 
 46 | # healthcheck is a tool/script used to check a challenge
 47 | # If connection_info was provided to CTFd when the challenge was installed, it will be passed to the healthcheck script:
 48 | # ./writeup/exploit.sh --connection-info "nc hostname 12345"
 49 | healthcheck: writeup/exploit.sh
 50 | 
 51 | # Can be removed if unused
 52 | attempts: 5
 53 | 
 54 | # Flags specify answers that your challenge use. You should generally provide at least one.
 55 | # Can be removed if unused
 56 | # Accepts strings or dictionaries of CTFd API data
 57 | flags:
 58 |     # A static case sensitive flag
 59 |     - flag{3xampl3}
 60 |     # A static case sensitive flag created with a dictionary
 61 |     - {
 62 |         type: "static",
 63 |         content: "flag{wat}",
 64 |         data: "case_sensitive",
 65 |     }
 66 |     # A static case insensitive flag
 67 |     - {
 68 |         type: "static",
 69 |         content: "flag{wat}",
 70 |         data: "case_insensitive",
 71 |     }
 72 |     # A regex case insensitive flag
 73 |     - {
 74 |         type: "regex",
 75 |         content: "(.*)STUFF(.*)",
 76 |         data: "case_insensitive",
 77 |     }
 78 | 
 79 | # Topics are used to help tell what techniques/information a challenge involves
 80 | # They are generally only visible to admins
 81 | # Accepts strings
 82 | topics:
 83 |     - information disclosure
 84 |     - buffer overflow
 85 |     - memory forensics
 86 | 
 87 | # Tags are used to provide additional public tagging to a challenge
 88 | # Can be removed if unused
 89 | # Accepts strings
 90 | tags:
 91 |     - web
 92 |     - sandbox
 93 |     - js
 94 | 
 95 | # Provide paths to files from the same directory that this file is in
 96 | # Accepts strings
 97 | files:
 98 |     - dist/source.py
 99 | 
100 | # Hints are used to give players a way to buy or have suggestions. They are not
101 | # required but can be nice.
102 | # Can be removed if unused
103 | # Accepts dictionaries or strings
104 | hints:
105 |     - {
106 |         content: "This hint costs points",
107 |         cost: 10
108 |     }
109 |     - This hint is free
110 |     - title: Titled Hint
111 |       content: This hint has a title and costs points
112 |       cost: 10
113 | 
114 | # Requirements are used to make a challenge require another challenge to be
115 | # solved before being available.
116 | # Can be removed if unused
117 | # Accepts challenge names as strings or challenge IDs as integers
118 | requirements:
119 |     - "Warmup"
120 |     - "Are you alive"
121 | 
122 | # The following format for requirements can also be used. This format can also
123 | # support the "anonymize" flag, which will display the challenge but with all 
124 | # the challenge information anonymized if it is not unlocked yet.
125 | #requirements:
126 | #    prerequisites:
127 | #        - "Warmup"
128 | #        - "Are you alive"
129 | #    anonymize: true
130 | 
131 | # The next is used to display a next recommended challenge to a user when 
132 | # the user correctly answers the current challenge.
133 | # Can be removed if unused
134 | # Accepts a challenge name as a string, a challenge ID as an integer, or null
135 | # if you want to remove or disable it.
136 | next: null
137 | 
138 | # The state of the challenge.
139 | # If the field is omitted, the challenge is visible by default.
140 | # If provided, the field can take one of two values: hidden, visible.
141 | state: hidden
142 | 
143 | # Specifies what version of the challenge specification was used.
144 | # Subject to change until ctfcli v1.0.0
145 | version: "0.1"
146 | 


--------------------------------------------------------------------------------
/ctfcli/templates/binary/default/cookiecutter.json:
--------------------------------------------------------------------------------
1 | {
2 |     "name": "Hello"
3 | }


--------------------------------------------------------------------------------
/ctfcli/templates/binary/default/{{cookiecutter.name}}/.dockerignore:
--------------------------------------------------------------------------------
 1 | # Challenge specific files
 2 | README.md
 3 | WRITEUP.md
 4 | challenge.yml
 5 | 
 6 | # Docker files
 7 | Dockerfile
 8 | docker-compose.yml
 9 | .dockerignore
10 | 
11 | # Build files
12 | Makefile
13 | .gitignore


--------------------------------------------------------------------------------
/ctfcli/templates/binary/default/{{cookiecutter.name}}/Makefile:
--------------------------------------------------------------------------------
 1 | .DEFAULT_GOAL := 64
 2 | 
 3 | 32:
 4 | 	gcc -g -Wall -m32 -o dist/{{cookiecutter.name}} src/{{cookiecutter.name}}.c
 5 | 
 6 | 64:
 7 | 	gcc -g -Wall -m64 -o dist/{{cookiecutter.name}} src/{{cookiecutter.name}}.c
 8 | 
 9 | clean:
10 | 	$(RM) dist/*
11 | 


--------------------------------------------------------------------------------
/ctfcli/templates/binary/default/{{cookiecutter.name}}/README.md:
--------------------------------------------------------------------------------
1 | # {{cookiecutter.name}}
2 | 
3 | ## Description
4 | 
5 | ## Topics


--------------------------------------------------------------------------------
/ctfcli/templates/binary/default/{{cookiecutter.name}}/challenge.yml:
--------------------------------------------------------------------------------
1 | ../../../../spec/challenge-example.yml


--------------------------------------------------------------------------------
/ctfcli/templates/binary/default/{{cookiecutter.name}}/src/{{cookiecutter.name}}.c:
--------------------------------------------------------------------------------
1 | #include <stdio.h>
2 | #include <string.h>
3 | #include <stdlib.h>
4 | 
5 | int main(int argc, char * argv[]) {
6 |   printf("Hello World!\n");
7 |   return 0;
8 | }
9 | 


--------------------------------------------------------------------------------
/ctfcli/templates/binary/default/{{cookiecutter.name}}/writeup/WRITEUP.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CTFd/ctfcli/c5abdd499bc9112c6832e047aa1c77b3052de05f/ctfcli/templates/binary/default/{{cookiecutter.name}}/writeup/WRITEUP.md


--------------------------------------------------------------------------------
/ctfcli/templates/blank/default/cookiecutter.json:
--------------------------------------------------------------------------------
1 | {
2 |     "name": "challenge"
3 | }


--------------------------------------------------------------------------------
/ctfcli/templates/blank/default/{{cookiecutter.name}}/README.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CTFd/ctfcli/c5abdd499bc9112c6832e047aa1c77b3052de05f/ctfcli/templates/blank/default/{{cookiecutter.name}}/README.md


--------------------------------------------------------------------------------
/ctfcli/templates/blank/default/{{cookiecutter.name}}/challenge.yml:
--------------------------------------------------------------------------------
1 | ../../../../spec/challenge-example.yml


--------------------------------------------------------------------------------
/ctfcli/templates/blank/default/{{cookiecutter.name}}/src/placeholder:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CTFd/ctfcli/c5abdd499bc9112c6832e047aa1c77b3052de05f/ctfcli/templates/blank/default/{{cookiecutter.name}}/src/placeholder


--------------------------------------------------------------------------------
/ctfcli/templates/blank/default/{{cookiecutter.name}}/writeup/WRITEUP.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CTFd/ctfcli/c5abdd499bc9112c6832e047aa1c77b3052de05f/ctfcli/templates/blank/default/{{cookiecutter.name}}/writeup/WRITEUP.md


--------------------------------------------------------------------------------
/ctfcli/templates/blank/empty/cookiecutter.json:
--------------------------------------------------------------------------------
1 | {
2 |     "name": "challenge",
3 | 	"dirname": "challenge"
4 | }


--------------------------------------------------------------------------------
/ctfcli/templates/blank/empty/{{cookiecutter.dirname}}/challenge.yml:
--------------------------------------------------------------------------------
1 | name: "{{cookiecutter.name}}"


--------------------------------------------------------------------------------
/ctfcli/templates/crypto/default/cookiecutter.json:
--------------------------------------------------------------------------------
1 | {
2 |     "name": "crypto-challenge"
3 | }


--------------------------------------------------------------------------------
/ctfcli/templates/crypto/default/{{cookiecutter.name}}/.gitignore:
--------------------------------------------------------------------------------
1 | __pycache__/


--------------------------------------------------------------------------------
/ctfcli/templates/crypto/default/{{cookiecutter.name}}/Makefile:
--------------------------------------------------------------------------------
1 | default:
2 | 	python src/encrypt.py > dist/flag.txt
3 | 
4 | clean:
5 | 	$(RM) dist/*
6 | 


--------------------------------------------------------------------------------
/ctfcli/templates/crypto/default/{{cookiecutter.name}}/README.md:
--------------------------------------------------------------------------------
1 | # {{cookiecutter.name}}
2 | 
3 | ## Description
4 | 
5 | ## Topics


--------------------------------------------------------------------------------
/ctfcli/templates/crypto/default/{{cookiecutter.name}}/challenge.yml:
--------------------------------------------------------------------------------
1 | ../../../../spec/challenge-example.yml


--------------------------------------------------------------------------------
/ctfcli/templates/crypto/default/{{cookiecutter.name}}/src/encrypt.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | import codecs
 3 | 
 4 | 
 5 | def encrypt(string):
 6 |     enc = codecs.getencoder("rot-13")
 7 |     return enc(string)[0]
 8 | 
 9 | 
10 | def main():
11 |     with open("src/flag.txt") as f:
12 |         print(encrypt(f.read()))
13 | 
14 | 
15 | if __name__ == "__main__":
16 |     main()
17 | 


--------------------------------------------------------------------------------
/ctfcli/templates/crypto/default/{{cookiecutter.name}}/src/flag.txt:
--------------------------------------------------------------------------------
1 | temp flag


--------------------------------------------------------------------------------
/ctfcli/templates/crypto/default/{{cookiecutter.name}}/writeup/WRITEUP.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CTFd/ctfcli/c5abdd499bc9112c6832e047aa1c77b3052de05f/ctfcli/templates/crypto/default/{{cookiecutter.name}}/writeup/WRITEUP.md


--------------------------------------------------------------------------------
/ctfcli/templates/programming/default/cookiecutter.json:
--------------------------------------------------------------------------------
1 | {
2 |     "name": "Hello",
3 |     "port": "12345",
4 |     "timeout": "60"
5 | }


--------------------------------------------------------------------------------
/ctfcli/templates/programming/default/{{cookiecutter.name}}/.dockerignore:
--------------------------------------------------------------------------------
 1 | # Challenge specific files
 2 | README.md
 3 | WRITEUP.md
 4 | challenge.yml
 5 | 
 6 | # Docker files
 7 | Dockerfile
 8 | docker-compose.yml
 9 | .dockerignore
10 | 
11 | # Build files
12 | Makefile
13 | .gitignore


--------------------------------------------------------------------------------
/ctfcli/templates/programming/default/{{cookiecutter.name}}/.gitignore:
--------------------------------------------------------------------------------
1 | __pycache__/


--------------------------------------------------------------------------------
/ctfcli/templates/programming/default/{{cookiecutter.name}}/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM python:3.7-slim-buster
 2 | 
 3 | RUN apt-get update -y \
 4 |     && apt-get install --no-install-recommends -y socat \
 5 |     && apt-get clean \
 6 |     && rm -rf /var/lib/apt/lists/*
 7 | 
 8 | RUN mkdir "/opt/{{cookiecutter.name}}"
 9 | COPY ./src/* "/opt/{{cookiecutter.name}}/"
10 | RUN pip install -r "/opt/{{cookiecutter.name}}/requirements.txt"
11 | WORKDIR "/opt/{{cookiecutter.name}}/"
12 | RUN chmod +x serve.sh server.py
13 | 
14 | EXPOSE {{cookiecutter.port}}
15 | CMD ./serve.sh
16 | 


--------------------------------------------------------------------------------
/ctfcli/templates/programming/default/{{cookiecutter.name}}/README.md:
--------------------------------------------------------------------------------
1 | # {{cookiecutter.name}}
2 | 
3 | ## Description
4 | 
5 | ## Topics


--------------------------------------------------------------------------------
/ctfcli/templates/programming/default/{{cookiecutter.name}}/challenge.yml:
--------------------------------------------------------------------------------
1 | ../../../../spec/challenge-example.yml


--------------------------------------------------------------------------------
/ctfcli/templates/programming/default/{{cookiecutter.name}}/docker-compose.yml:
--------------------------------------------------------------------------------
1 | version: "3"
2 | services:
3 |   app:
4 |     build: .
5 |     ports:
6 |         - '{{cookiecutter.port}}'
7 | 


--------------------------------------------------------------------------------
/ctfcli/templates/programming/default/{{cookiecutter.name}}/src/requirements.txt:
--------------------------------------------------------------------------------
1 | six==1.16.0
2 | 


--------------------------------------------------------------------------------
/ctfcli/templates/programming/default/{{cookiecutter.name}}/src/serve.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | socat \
3 |     -T{{cookiecutter.timeout}} \
4 |     TCP-LISTEN:{{cookiecutter.port}},reuseaddr,fork \
5 |     EXEC:"timeout {{cookiecutter.timeout}} ./server.py"


--------------------------------------------------------------------------------
/ctfcli/templates/programming/default/{{cookiecutter.name}}/src/server.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | import random
 3 | 
 4 | from six.moves import input
 5 | 
 6 | 
 7 | def server():
 8 |     print("Hello World")
 9 |     secret = random.randint(1, 100)
10 |     while True:
11 |         guess = input("What's the random number?")
12 |         if int(guess) == secret:
13 |             print("You got it!")
14 |             exit()
15 |         else:
16 |             print("No.")
17 | 
18 | 
19 | if __name__ == "__main__":
20 |     server()
21 | 


--------------------------------------------------------------------------------
/ctfcli/templates/programming/default/{{cookiecutter.name}}/writeup/WRITEUP.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CTFd/ctfcli/c5abdd499bc9112c6832e047aa1c77b3052de05f/ctfcli/templates/programming/default/{{cookiecutter.name}}/writeup/WRITEUP.md


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/cookiecutter.json:
--------------------------------------------------------------------------------
1 | {
2 |     "name": "Hello"
3 | }


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/{{cookiecutter.name}}/.dockerignore:
--------------------------------------------------------------------------------
 1 | # Challenge specific files
 2 | README.md
 3 | WRITEUP.md
 4 | challenge.yml
 5 | 
 6 | # Docker files
 7 | Dockerfile
 8 | docker-compose.yml
 9 | .dockerignore
10 | 
11 | # Build files
12 | Makefile
13 | .gitignore


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/{{cookiecutter.name}}/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM python:3.7-slim-buster
 2 | RUN adduser \
 3 |     --disabled-login \
 4 |     -u 1001 \
 5 |     --gecos "" \
 6 |     --shell /bin/bash \
 7 |     app
 8 | WORKDIR /opt/app
 9 | RUN mkdir -p /opt/app
10 | 
11 | COPY src/ /opt/app/
12 | RUN pip install -r requirements.txt
13 | RUN chown -R 1001:1001 /opt/app && chmod -R 755 /opt/app
14 | 
15 | USER 1001
16 | EXPOSE 8000
17 | ENTRYPOINT ["/opt/app/serve.sh"]
18 | 


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/{{cookiecutter.name}}/README.md:
--------------------------------------------------------------------------------
1 | # {{cookiecutter.name}}
2 | 
3 | ## Description
4 | 
5 | ## Topics


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/{{cookiecutter.name}}/challenge.yml:
--------------------------------------------------------------------------------
1 | ../../../../spec/challenge-example.yml


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/{{cookiecutter.name}}/docker-compose.yml:
--------------------------------------------------------------------------------
1 | version: "3"
2 | services:
3 |   app:
4 |     build: .
5 |     ports:
6 |         - '8000:8000'
7 | 


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/{{cookiecutter.name}}/src/app.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | import functools
  3 | 
  4 | from flask import Flask, redirect, render_template, request, session, url_for
  5 | from flask_bootstrap import Bootstrap
  6 | from models import Users, db, hash_password, verify_password
  7 | from sqlalchemy.exc import IntegrityError
  8 | 
  9 | app = Flask(__name__)
 10 | app.config.from_object("config.Config")
 11 | bootstrap = Bootstrap(app)
 12 | 
 13 | db.init_app(app)
 14 | with app.app_context():
 15 |     db.create_all()
 16 | 
 17 | 
 18 | def authed():
 19 |     user_id = session.get("id", None)
 20 |     return user_id is not None
 21 | 
 22 | 
 23 | def authed_only(f):
 24 |     @functools.wraps(f)
 25 |     def _authed_only(*args, **kwargs):
 26 |         if authed():
 27 |             return f(*args, **kwargs)
 28 |         else:
 29 |             return redirect(url_for("login", next=request.full_path))
 30 | 
 31 |     return _authed_only
 32 | 
 33 | 
 34 | @app.context_processor
 35 | def inject_user():
 36 |     if session:
 37 |         return dict(session)
 38 |     return dict()
 39 | 
 40 | 
 41 | @app.route("/")
 42 | def index():
 43 |     return render_template("index.html")
 44 | 
 45 | 
 46 | @app.route("/profile")
 47 | def profile():
 48 |     user = Users.query.filter_by(id=session["id"]).first()
 49 |     return render_template("profile.html", user=user)
 50 | 
 51 | 
 52 | @app.route("/logout")
 53 | def logout():
 54 |     session.clear()
 55 |     return redirect("/")
 56 | 
 57 | 
 58 | @app.route("/login", methods=["GET", "POST"])
 59 | def login():
 60 |     if request.method == "POST":
 61 |         username = request.form["username"]
 62 |         password = request.form["password"].strip()
 63 |         errors = []
 64 | 
 65 |         user = Users.query.filter_by(username=username).first()
 66 |         if user:
 67 |             pass_test = verify_password(plaintext=password, ciphertext=user.password)
 68 |             if pass_test is False:
 69 |                 errors.append("Incorrect password")
 70 |         else:
 71 |             errors.append("User does not exist")
 72 |             return render_template("login.html", errors=errors)
 73 | 
 74 |         if errors:
 75 |             return render_template("login.html", errors=errors)
 76 | 
 77 |         session["id"] = user.id
 78 |         session["username"] = user.username
 79 | 
 80 |     return redirect("/")
 81 | 
 82 | 
 83 | @app.route("/register", methods=["GET", "POST"])
 84 | def register():
 85 |     if request.method == "POST":
 86 |         username = request.form["username"]
 87 |         password = request.form["password"]
 88 | 
 89 |         try:
 90 |             user = Users(username=username, password=password)
 91 |             db.session.add(user)
 92 |             db.session.commit()
 93 |         except IntegrityError:
 94 |             return render_template(
 95 |                 "register.html", errors=["That username is already taken"]
 96 |             )
 97 | 
 98 |         session["id"] = user.id
 99 |         return redirect("/")
100 | 
101 |     return render_template("register.html")
102 | 
103 | 
104 | if __name__ == "__main__":
105 |     app.run(debug=True, threaded=True)
106 | 


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/{{cookiecutter.name}}/src/config.py:
--------------------------------------------------------------------------------
1 | import os
2 | 
3 | 
4 | class Config(object):
5 |     SECRET_KEY = os.urandom(32)
6 |     BOOTSTRAP_SERVE_LOCAL = True
7 |     SQLALCHEMY_DATABASE_URI = "sqlite:///app.db"
8 |     SQLALCHEMY_TRACK_MODIFICATIONS = False
9 | 


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/{{cookiecutter.name}}/src/models.py:
--------------------------------------------------------------------------------
 1 | import hashlib
 2 | 
 3 | from flask_sqlalchemy import SQLAlchemy
 4 | from sqlalchemy.orm import validates
 5 | 
 6 | db = SQLAlchemy()
 7 | 
 8 | 
 9 | def hash_password(s):
10 |     if isinstance(s, str):
11 |         s = s.encode("utf8")
12 |     return hashlib.sha1(s).hexdigest()
13 | 
14 | 
15 | def verify_password(plaintext, ciphertext):
16 |     return hash_password(plaintext) == ciphertext
17 | 
18 | 
19 | class Users(db.Model):
20 |     id = db.Column(db.Integer, primary_key=True)
21 |     username = db.Column(db.String(128), unique=True)
22 |     password = db.Column(db.String(128))
23 | 
24 |     @validates("password")
25 |     def validate_password(self, key, plaintext):
26 |         return hash_password(str(plaintext))
27 | 


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/{{cookiecutter.name}}/src/requirements.txt:
--------------------------------------------------------------------------------
1 | gunicorn==20.0.4
2 | Flask==1.1.1
3 | Bootstrap-Flask==1.2.0
4 | Flask-SQLAlchemy==2.4.4
5 | SQLAlchemy==1.3.17
6 | 


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/{{cookiecutter.name}}/src/serve.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | gunicorn 'app:app' \
3 |     --bind '0.0.0.0:8000' \
4 |     --workers 4 \
5 |     --access-logfile "-" \
6 |     --error-logfile "-"


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/{{cookiecutter.name}}/src/static/css/main.css:
--------------------------------------------------------------------------------
1 | main {
2 |     margin-top: 60px;
3 | }
4 | 


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/{{cookiecutter.name}}/src/templates/base.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | 
 4 | {% raw %}
 5 | <head>
 6 |     <meta charset="utf-8">
 7 |     <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
 8 | 
 9 |     {% block bootstrap_css %}
10 |     {{ bootstrap.load_css() }}
11 |     {% endblock %}
12 | 
13 |     <link rel="stylesheet" href="/static/css/main.css">
14 | 
15 |     {% block styles %}
16 |     {% endblock %}
17 | </head>
18 | {% endraw %}
19 | 
20 | <body>
21 |     <nav class="navbar navbar-expand-md navbar-dark fixed-top bg-dark">
22 |         <a class="navbar-brand" href="#">{{cookiecutter.name}}</a>
23 | 
24 |         <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarCollapse">
25 |             <span class="navbar-toggler-icon"></span>
26 |         </button>
27 | 
28 |         <div class="collapse navbar-collapse" id="navbarCollapse">
29 |             <ul class="navbar-nav mr-auto">
30 |                 <li class="nav-item active">
31 |                     <a class="nav-link" href="#">Home <span class="sr-only">(current)</span></a>
32 |                 </li>
33 |                 <li class="nav-item">
34 |                     <a class="nav-link" href="#">Link</a>
35 |                 </li>
36 |             </ul>
37 |             {% raw %}
38 |             <ul class="navbar-nav">
39 |                 {% if id is defined %}
40 |                 <li class="nav-item">
41 |                     <a class="nav-link" href="{{ url_for('profile') }}">Profile</a>
42 |                 </li>
43 |                 <li class="nav-item">
44 |                     <a class="nav-link" href="{{ url_for('logout') }}">Logout</a>
45 |                 </li>
46 |                 {% else %}
47 |                 <li class="nav-item">
48 |                     <a class="nav-link" href="{{ url_for('login') }}">Login</a>
49 |                 </li>
50 |                 <li class="nav-item">
51 |                     <a class="nav-link" href="{{ url_for('register') }}">Register</a>
52 |                 </li>
53 |                 {% endif %}
54 |             </ul>
55 |             {% endraw %}
56 |         </div>
57 |     </nav>
58 | 
59 |     {% raw %}
60 |     <main role="main" class="container">
61 |         {% block content %}{% endblock %}
62 |     </main>
63 |     {% endraw %}
64 | 
65 | 
66 |     {% raw %}
67 |     {% block bootstrap_js %}
68 |     {{ bootstrap.load_js() }}
69 |     {% endblock %}
70 | 
71 |     {% block scripts %}
72 |     {% endblock %}
73 |     {% endraw %}
74 | </body>
75 | 
76 | </html>
77 | 


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/{{cookiecutter.name}}/src/templates/index.html:
--------------------------------------------------------------------------------
1 | {% raw %}
2 | {% extends "base.html" %}
3 | 
4 | {% block content %}
5 | Index page
6 | {% endblock %}
7 | 
8 | {% endraw %}


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/{{cookiecutter.name}}/src/templates/login.html:
--------------------------------------------------------------------------------
 1 | {% raw %}
 2 | {% extends "base.html" %}
 3 | 
 4 | {% block content %}
 5 | <div class="row pt-5">
 6 |     <div class="col-md-6 offset-md-3">
 7 |         <form class="text-center p-5 border" method="POST">
 8 |             <p class="h4 mb-4">Login</p>
 9 |             {% for error in errors %}
10 |                 <div class="alert alert-danger alert-dismissable text-center" role="alert">
11 |                     <span>{{ error }}</span>
12 |                     <button type="button" class="close" data-dismiss="alert" aria-label="Close">
13 |                         <span aria-hidden="true">×</span>
14 |                     </button>
15 |                 </div>
16 |             {% endfor %}
17 | 
18 |             <input type="text" name="username" class="form-control mb-4" placeholder="Username" required>
19 |             <input type="password" name="password" class="form-control mb-4" placeholder="Password" required>
20 |             <input class="btn btn-primary btn-block my-4" type="submit" value="Sign in">
21 |         </form>
22 |     </div>
23 | </div>
24 | {% endblock %}
25 | {% endraw %}
26 | 


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/{{cookiecutter.name}}/src/templates/profile.html:
--------------------------------------------------------------------------------
 1 | {% raw %}
 2 | {% extends "base.html" %}
 3 | 
 4 | {% block content %}
 5 | <div class="row pt-5">
 6 |     <div class="col-md-6 offset-md-3">
 7 |         <h1>Profile</h1>
 8 |         <hr>
 9 |         {{ user.username }}
10 |     </div>
11 | </div>
12 | {% endblock %}
13 | {% endraw %}
14 | 


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/{{cookiecutter.name}}/src/templates/register.html:
--------------------------------------------------------------------------------
 1 | {% raw %}
 2 | {% extends "base.html" %}
 3 | 
 4 | {% block content %}
 5 | <div class="row pt-5">
 6 |     <div class="col-md-6 offset-md-3">
 7 |         <form class="text-center p-5 border" method="POST">
 8 |             <p class="h4 mb-4">Register</p>
 9 |             {% for error in errors %}
10 |                 <div class="alert alert-danger alert-dismissable text-center" role="alert">
11 |                     <span>{{ error }}</span>
12 |                     <button type="button" class="close" data-dismiss="alert" aria-label="Close">
13 |                         <span aria-hidden="true">×</span>
14 |                     </button>
15 |                 </div>
16 |             {% endfor %}
17 | 
18 |             <input type="text" name="username" class="form-control mb-4" placeholder="Username" required>
19 |             <input type="password" name="password" class="form-control mb-4" placeholder="Password" required>
20 |             <button class="btn btn-primary btn-block my-4" type="submit">Create Account</button>
21 |         </form>
22 |     </div>
23 | </div>
24 | {% endblock %}
25 | {% endraw %}


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/{{cookiecutter.name}}/writeup/WRITEUP.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CTFd/ctfcli/c5abdd499bc9112c6832e047aa1c77b3052de05f/ctfcli/templates/web/default/{{cookiecutter.name}}/writeup/WRITEUP.md


--------------------------------------------------------------------------------
/ctfcli/utils/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CTFd/ctfcli/c5abdd499bc9112c6832e047aa1c77b3052de05f/ctfcli/utils/__init__.py


--------------------------------------------------------------------------------
/ctfcli/utils/git.py:
--------------------------------------------------------------------------------
 1 | import subprocess
 2 | from os import PathLike
 3 | from typing import Optional, Union
 4 | 
 5 | 
 6 | def check_if_git_subrepo_is_installed() -> bool:
 7 |     output = subprocess.run(["git", "subrepo"], capture_output=True, text=True)
 8 |     if "git: 'subrepo' is not a git command" in output.stderr:
 9 |         return False
10 |     return True
11 | 
12 | 
13 | def get_git_repo_head_branch(repo: str) -> Optional[str]:
14 |     """
15 |     A helper method to get the reference of the HEAD branch of a git remote repo.
16 |     https://stackoverflow.com/a/41925348
17 |     """
18 |     try:
19 |         output = subprocess.check_output(["git", "ls-remote", "--symref", repo, "HEAD"], stderr=subprocess.DEVNULL)
20 | 
21 |         # if for some reason subprocess didn't error, but returned None or an empty byte-string - return None
22 |         # this can happen if a repository exists, but doesn't have a head branch
23 |         if type(output) != bytes or len(output) == 0:
24 |             return None
25 | 
26 |     except subprocess.CalledProcessError:
27 |         return None
28 | 
29 |     # otherwise process the output
30 |     output = output.decode().strip()
31 |     head_branch_line = output.split()[1]
32 |     if head_branch_line.startswith("refs/heads/"):
33 |         return head_branch_line[11:]
34 | 
35 | 
36 | def check_if_dir_is_inside_git_repo(cwd: Optional[Union[str, PathLike]] = None) -> bool:
37 |     """
38 |     Checks whether a given directory is inside a git repo.
39 |     """
40 |     try:
41 |         out = (
42 |             subprocess.check_output(
43 |                 ["git", "rev-parse", "--is-inside-work-tree"],
44 |                 cwd=cwd,
45 |                 stderr=subprocess.DEVNULL,
46 |             )
47 |             .decode()
48 |             .strip()
49 |         )
50 | 
51 |         if out == "true":
52 |             return True
53 | 
54 |         return False
55 |     except subprocess.CalledProcessError:
56 |         return False
57 | 


--------------------------------------------------------------------------------
/ctfcli/utils/hashing.py:
--------------------------------------------------------------------------------
 1 | import hashlib
 2 | 
 3 | 
 4 | def hash_file(fp, algo="sha1"):
 5 |     fp.seek(0)
 6 |     if algo == "sha1":
 7 |         h = hashlib.sha1()  # nosec
 8 |         # https://stackoverflow.com/a/64730457
 9 |         while chunk := fp.read(1024):
10 |             h.update(chunk)
11 |         fp.seek(0)
12 |         return h.hexdigest()
13 |     else:
14 |         raise NotImplementedError
15 | 


--------------------------------------------------------------------------------
/ctfcli/utils/tools.py:
--------------------------------------------------------------------------------
 1 | import re
 2 | import string
 3 | 
 4 | 
 5 | def strings(filename, min_length=4):
 6 |     """
 7 |     Python implementation of strings
 8 |     https://stackoverflow.com/a/17197027
 9 |     """
10 |     with open(filename, errors="ignore") as f:
11 |         result = ""
12 | 
13 |         for c in f.read():
14 |             if c in string.printable:
15 |                 result += c
16 |                 continue
17 | 
18 |             if len(result) >= min_length:
19 |                 yield result
20 | 
21 |             result = ""
22 | 
23 |         if len(result) >= min_length:  # catch result at EOF
24 |             yield result
25 | 
26 | 
27 | def safe_format(fmt, items):
28 |     """
29 |     Function that safely formats strings with arbitrary potentially user-supplied format strings
30 |     Looks for interpolation placeholders like {target} or {{ target }}
31 |     """
32 |     return re.sub(r"\{?\{([^{}]*)\}\}?", lambda m: items.get(m.group(1).strip(), m.group(0)), fmt)
33 | 


--------------------------------------------------------------------------------
/docs/plugins.md:
--------------------------------------------------------------------------------
 1 | # Plugins
 2 | 
 3 | `ctfcli` plugins are essentially additions to to the command line interface via dynamic class modifications.
 4 | 
 5 | *`ctfcli` is an alpha project! The plugin interface is likely to change!*
 6 | 
 7 | ## Installing a plugin
 8 | 
 9 | `ctfcli` expects plugins to be shared via git repositories. The `ctf plugins install` command will clone a given plugin repository to the plugin directory.
10 | 
11 | ```
12 | ❯ ctf plugins install URL
13 | ```
14 | 
15 | ## Writing a new plugin
16 | 
17 | ### 1. Locate your plugin directory
18 | ```
19 | ❯ ctf plugins dir
20 | /Users/user/Library/Application Support/ctfcli/plugins
21 | ```
22 | 
23 | ### 2. Create a new module
24 | 
25 | Create a new Python module with an `__init__.py` file inside of it. Inside of the `__init__.py` file you should specify a load function that takes a single argument (the pre-defined command classes)
26 | 
27 | ```
28 | .
29 | └── plugin
30 |     └── __init__.py
31 | ```
32 | 
33 | ```
34 | ❯ cat plugin/__init__.py
35 | from types import MethodType
36 | 
37 | 
38 | def load(commands):
39 |     pass
40 | ```
41 | 
42 | ### 3. Define your plugin
43 | 
44 | ```python
45 | from types import MethodType
46 | 
47 | 
48 | def cow(self):
49 |     a_cow = """
50 | ^__^
51 | (oo)\_______
52 | (__)\       )\\/\\
53 |     ||----w |
54 |     ||     ||
55 | """
56 |     print(a_cow)
57 | 
58 | 
59 | def load(commands):
60 |     plugins = commands["plugins"]
61 |     plugins.cow = MethodType(cow, plugins)
62 | ```
63 | 
64 | ### 4. Run your new command
65 | 
66 | ```
67 | ❯ ctf plugins cow
68 | Loading /Users/user/Library/Application Support/ctfcli/plugins/plugin/__init__.py as plugin
69 | 
70 | ^__^
71 | (oo)\_______
72 | (__)\       )\/\
73 |     ||----w |
74 |     ||     ||
75 | ```


--------------------------------------------------------------------------------
/preprocess.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | 
 3 | 
 4 | def replace_symlinks():
 5 |     os.system("""find . -type l -exec sh -c 'target=$(readlink -f "$0"); rm "$0" && cp "$target" "$0"' {} \\;""")
 6 | 
 7 | 
 8 | if __name__ == "__main__":
 9 |     replace_symlinks()
10 | 


--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
 1 | [tool.poetry]
 2 | name = "ctfcli"
 3 | version = "0.1.4"
 4 | description = "ctfcli is a tool to manage Capture The Flag events and challenges"
 5 | authors = ["Kevin Chung <kchung@ctfd.io>", "Miłosz Skaza <milosz.skaza@ctfd.io>"]
 6 | readme = "README.md"
 7 | 
 8 | [tool.poetry.scripts]
 9 | ctf = "ctfcli.__main__:main"
10 | 
11 | [tool.poetry.build]
12 | # I don't understand why poetry doesn't seem to be following symlinks. 
13 | # This script resolves the symlinks in the templates to the example challenge spec
14 | script = "preprocess.py"
15 | 
16 | [tool.poetry.dependencies]
17 | python = "^3.8"
18 | python-frontmatter = "^1.0.0"
19 | requests = "^2.31.0"
20 | pyyaml = "^6.0.1"
21 | click = "^8.1.7"
22 | cookiecutter = "^2.3.0"
23 | appdirs = "^1.4.4"
24 | colorama = "^0.4.6"
25 | fire = "^0.7.0"
26 | typing-extensions = "^4.7.1"
27 | python-slugify = "^8.0.4"
28 | 
29 | [tool.poetry.group.dev.dependencies]
30 | black = "^23.7.0"
31 | ruff = "^0.0.284"
32 | isort = "^5.12.0"
33 | pytest = "^7.4.0"
34 | pytest-sugar = "^0.9.7"
35 | pytest-cov = "^4.1.0"
36 | 
37 | [tool.ruff]
38 | line-length = 120
39 | ignore = ["E721"]
40 | exclude = ["build", "ctfcli/templates"]
41 | 
42 | [tool.isort]
43 | profile = "black"
44 | 
45 | [tool.black]
46 | line-length = 120
47 | target-version = ['py311']
48 | extend-exclude = '''
49 | (
50 |   /build
51 |   | /ctfcli/templates
52 |   | /venv
53 | )
54 | '''
55 | 
56 | [build-system]
57 | requires = ["poetry-core"]
58 | build-backend = "poetry.core.masonry.api"
59 | 


--------------------------------------------------------------------------------
/tests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CTFd/ctfcli/c5abdd499bc9112c6832e047aa1c77b3052de05f/tests/__init__.py


--------------------------------------------------------------------------------
/tests/cli/test_main.py:
--------------------------------------------------------------------------------
 1 | import contextlib
 2 | import io
 3 | import unittest
 4 | 
 5 | import fire
 6 | 
 7 | from ctfcli import __main__ as ctfcli
 8 | 
 9 | 
10 | class TestCLIEntrypoint(unittest.TestCase):
11 |     def test_loads_challenge_command(self):
12 |         stdout = io.StringIO()
13 |         with contextlib.redirect_stdout(stdout):
14 |             fire.Fire(ctfcli.CTFCLI, ["challenge"])
15 | 
16 |         # fmt: off
17 |         expected_commands = [
18 |             "add", "deploy", "edit", "healthcheck",
19 |             "install", "lint", "new", "pull", "push",
20 |             "restore", "show", "sync", "templates",
21 |             "view",
22 |         ]
23 |         # fmt: on
24 | 
25 |         stdout = stdout.getvalue()
26 |         for command in expected_commands:
27 |             self.assertIn(command, stdout)
28 | 
29 |     def test_loads_config_command(self):
30 |         stdout = io.StringIO()
31 |         with contextlib.redirect_stdout(stdout):
32 |             fire.Fire(ctfcli.CTFCLI, ["config"])
33 | 
34 |         expected_commands = ["edit", "path", "show", "view"]
35 | 
36 |         stdout = stdout.getvalue()
37 |         for command in expected_commands:
38 |             self.assertIn(command, stdout)
39 | 
40 |     def test_loads_pages_command(self):
41 |         stdout = io.StringIO()
42 |         with contextlib.redirect_stdout(stdout):
43 |             fire.Fire(ctfcli.CTFCLI, ["pages"])
44 | 
45 |         expected_commands = ["pull", "push", "sync"]
46 | 
47 |         stdout = stdout.getvalue()
48 |         for command in expected_commands:
49 |             self.assertIn(command, stdout)
50 | 
51 |     def test_loads_plugins_command(self):
52 |         stdout = io.StringIO()
53 |         with contextlib.redirect_stdout(stdout):
54 |             fire.Fire(ctfcli.CTFCLI, ["plugins"])
55 | 
56 |         expected_commands = ["dir", "install", "list", "path", "uninstall"]
57 | 
58 |         stdout = stdout.getvalue()
59 |         for command in expected_commands:
60 |             self.assertIn(command, stdout)
61 | 
62 |     def test_loads_templates_command(self):
63 |         stdout = io.StringIO()
64 |         with contextlib.redirect_stdout(stdout):
65 |             fire.Fire(ctfcli.CTFCLI, ["templates"])
66 | 
67 |         expected_commands = ["dir", "install", "list", "path", "uninstall"]
68 | 
69 |         stdout = stdout.getvalue()
70 |         for command in expected_commands:
71 |             self.assertIn(command, stdout)
72 | 


--------------------------------------------------------------------------------
/tests/core/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CTFd/ctfcli/c5abdd499bc9112c6832e047aa1c77b3052de05f/tests/core/__init__.py


--------------------------------------------------------------------------------
/tests/core/deployment/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CTFd/ctfcli/c5abdd499bc9112c6832e047aa1c77b3052de05f/tests/core/deployment/__init__.py


--------------------------------------------------------------------------------
/tests/core/deployment/test_base_deployment_handler.py:
--------------------------------------------------------------------------------
 1 | import unittest
 2 | from pathlib import Path
 3 | 
 4 | from ctfcli.core.challenge import Challenge
 5 | from ctfcli.core.deployment import (
 6 |     DEPLOYMENT_HANDLERS,
 7 |     CloudDeploymentHandler,
 8 |     DeploymentHandler,
 9 |     RegistryDeploymentHandler,
10 |     SSHDeploymentHandler,
11 |     get_deployment_handler,
12 |     register_deployment_handler,
13 | )
14 | from ctfcli.core.deployment.base import DeploymentResult
15 | 
16 | BASE_DIR = Path(__file__).parent.parent.parent
17 | 
18 | 
19 | class TestDeploymentHandlerLoading(unittest.TestCase):
20 |     def test_get_deployment_handler(self):
21 |         handlers = {
22 |             "cloud": CloudDeploymentHandler,
23 |             "ssh": SSHDeploymentHandler,
24 |             "registry": RegistryDeploymentHandler,
25 |         }
26 | 
27 |         for key, handler in handlers.items():
28 |             handler_class = get_deployment_handler(key)
29 |             self.assertIs(handlers[key], handler_class)
30 | 
31 |     def test_register_deployment_handler(self):
32 |         class MyDeploymentHandler(DeploymentHandler):
33 |             def deploy(self, *args, **kwargs) -> DeploymentResult:
34 |                 return DeploymentResult(False)
35 | 
36 |         register_deployment_handler("my-handler", MyDeploymentHandler)
37 |         self.assertIs(DEPLOYMENT_HANDLERS["my-handler"], MyDeploymentHandler)
38 | 
39 | 
40 | class TestBaseDeploymentHandler(unittest.TestCase):
41 |     challenge_directory = BASE_DIR / "fixtures" / "challenges" / "test-challenge-dockerfile"
42 |     challenge_path = challenge_directory / "challenge.yml"
43 | 
44 |     def test_assigns_attributes(self):
45 |         challenge = Challenge(self.challenge_path)
46 |         handler = DeploymentHandler(challenge, "example.com", "https")
47 | 
48 |         self.assertIs(challenge, handler.challenge)
49 |         self.assertEqual("example.com", handler.host)
50 |         self.assertEqual("https", handler.protocol)
51 | 
52 |     def test_does_not_implement_deploy(self):
53 |         challenge = Challenge(self.challenge_path)
54 |         handler = DeploymentHandler(challenge, "example.com", "https")
55 | 
56 |         with self.assertRaises(NotImplementedError):
57 |             handler.deploy()
58 | 


--------------------------------------------------------------------------------
/tests/core/deployment/test_registry_deployment.py:
--------------------------------------------------------------------------------
  1 | import unittest
  2 | from pathlib import Path
  3 | from subprocess import CalledProcessError
  4 | from unittest import mock
  5 | from unittest.mock import MagicMock, call
  6 | 
  7 | from ctfcli.core.challenge import Challenge
  8 | from ctfcli.core.deployment import RegistryDeploymentHandler
  9 | from ctfcli.core.deployment.base import DeploymentResult
 10 | 
 11 | BASE_DIR = Path(__file__).parent.parent.parent
 12 | 
 13 | 
 14 | class TestRegistryDeployment(unittest.TestCase):
 15 |     challenge_directory = BASE_DIR / "fixtures" / "challenges" / "test-challenge-dockerfile"
 16 |     challenge_path = challenge_directory / "challenge.yml"
 17 | 
 18 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
 19 |     @mock.patch("ctfcli.core.deployment.registry.subprocess.run")
 20 |     @mock.patch("ctfcli.core.deployment.registry.Config")
 21 |     @mock.patch("ctfcli.core.challenge.Image")
 22 |     def test_builds_and_pushes_image(
 23 |         self,
 24 |         mock_image_constructor: MagicMock,
 25 |         mock_config_constructor: MagicMock,
 26 |         *args,
 27 |         **kwargs,
 28 |     ):
 29 |         challenge = Challenge(self.challenge_path)
 30 | 
 31 |         mock_image: MagicMock = mock_image_constructor.return_value
 32 |         mock_image.name = "test-challenge"
 33 |         mock_image.basename = "test-challenge"
 34 |         mock_image.build.return_value = "test-challenge"
 35 |         mock_image.push.return_value = "registry.example.com/example-project/test-challenge"
 36 | 
 37 |         mock_config_constructor.return_value = {"registry": {"username": "test", "password": "test"}}
 38 | 
 39 |         handler = RegistryDeploymentHandler(challenge, host="registry://registry.example.com/example-project")
 40 |         result = handler.deploy()
 41 | 
 42 |         self.assertIsInstance(result, DeploymentResult)
 43 |         self.assertTrue(result.success)
 44 | 
 45 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
 46 |     @mock.patch("ctfcli.core.deployment.registry.click.secho")
 47 |     def test_fails_deployment_if_challenge_does_not_provide_image(self, mock_secho: MagicMock, *args, **kwargs):
 48 |         challenge = Challenge(self.challenge_path, {"image": None, "host": "registry.example.com/example-project"})
 49 |         handler = RegistryDeploymentHandler(challenge)
 50 |         result = handler.deploy()
 51 | 
 52 |         self.assertIsInstance(result, DeploymentResult)
 53 |         self.assertFalse(result.success)
 54 |         mock_secho.assert_called_once_with("Challenge does not define an image to deploy", fg="red")
 55 | 
 56 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
 57 |     @mock.patch("ctfcli.core.deployment.registry.click.secho")
 58 |     def test_fails_deployment_if_no_host_provided(self, mock_secho: MagicMock, *args, **kwargs):
 59 |         challenge = Challenge(self.challenge_path)
 60 |         handler = RegistryDeploymentHandler(challenge)
 61 |         result = handler.deploy()
 62 | 
 63 |         self.assertIsInstance(result, DeploymentResult)
 64 |         self.assertFalse(result.success)
 65 |         mock_secho.assert_called_once_with(
 66 |             "No host provided for the deployment. Use --host, or define host in the challenge.yml file", fg="red"
 67 |         )
 68 | 
 69 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
 70 |     @mock.patch("ctfcli.core.deployment.registry.click.secho")
 71 |     @mock.patch("ctfcli.core.challenge.Image")
 72 |     def test_fails_deployment_if_no_registry_config(
 73 |         self,
 74 |         mock_image_constructor: MagicMock,
 75 |         mock_secho: MagicMock,
 76 |         *args,
 77 |         **kwargs,
 78 |     ):
 79 |         challenge = Challenge(self.challenge_path)
 80 | 
 81 |         mock_image: MagicMock = mock_image_constructor.return_value
 82 |         mock_image.name = "test-challenge"
 83 |         mock_image.basename = "test-challenge"
 84 |         mock_image.build.return_value = "test-challenge"
 85 | 
 86 |         handler = RegistryDeploymentHandler(challenge, host="registry://registry.example.com/example-project")
 87 |         result = handler.deploy()
 88 | 
 89 |         self.assertIsInstance(result, DeploymentResult)
 90 |         self.assertFalse(result.success)
 91 |         mock_secho.assert_called_once_with("Config does not provide a registry section.", fg="red")
 92 | 
 93 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
 94 |     @mock.patch("ctfcli.core.deployment.registry.click.secho")
 95 |     @mock.patch("ctfcli.core.deployment.registry.Config")
 96 |     @mock.patch("ctfcli.core.challenge.Image")
 97 |     def test_fails_if_no_credentials(
 98 |         self,
 99 |         mock_image_constructor: MagicMock,
100 |         mock_config_constructor: MagicMock,
101 |         mock_secho: MagicMock,
102 |         *args,
103 |         **kwargs,
104 |     ):
105 |         challenge = Challenge(self.challenge_path)
106 | 
107 |         mock_image: MagicMock = mock_image_constructor.return_value
108 |         mock_image.name = "test-challenge"
109 |         mock_image.basename = "test-challenge"
110 |         mock_image.build.return_value = "test-challenge"
111 | 
112 |         mock_config_constructor.return_value = {"registry": {"username": "test"}}
113 | 
114 |         handler = RegistryDeploymentHandler(challenge, host="registry://registry.example.com/example-project")
115 |         result = handler.deploy()
116 | 
117 |         self.assertIsInstance(result, DeploymentResult)
118 |         self.assertFalse(result.success)
119 |         mock_secho.assert_called_once_with("Config is missing credentials for the registry.", fg="red")
120 | 
121 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
122 |     @mock.patch("ctfcli.core.deployment.registry.click.secho")
123 |     @mock.patch("ctfcli.core.deployment.registry.subprocess.run")
124 |     @mock.patch("ctfcli.core.deployment.registry.Config")
125 |     @mock.patch("ctfcli.core.challenge.Image")
126 |     def test_fails_if_registry_credentials_invalid(
127 |         self,
128 |         mock_image_constructor: MagicMock,
129 |         mock_config_constructor: MagicMock,
130 |         mock_subprocess: MagicMock,
131 |         mock_secho: MagicMock,
132 |         *args,
133 |         **kwargs,
134 |     ):
135 |         challenge = Challenge(self.challenge_path)
136 | 
137 |         mock_image: MagicMock = mock_image_constructor.return_value
138 |         mock_image.name = "test-challenge"
139 |         mock_image.basename = "test-challenge"
140 |         mock_image.build.return_value = "test-challenge"
141 | 
142 |         mock_config_constructor.return_value = {"registry": {"username": "test", "password": "test"}}
143 |         mock_subprocess.side_effect = [CalledProcessError(1, "")]
144 | 
145 |         handler = RegistryDeploymentHandler(challenge, host="registry://registry.example.com/example-project")
146 |         result = handler.deploy()
147 | 
148 |         self.assertIsInstance(result, DeploymentResult)
149 |         self.assertFalse(result.success)
150 |         mock_secho.assert_called_once_with(
151 |             "Could not log in to the registry. Please check your configured credentials.", fg="red"
152 |         )
153 | 
154 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
155 |     @mock.patch("ctfcli.core.deployment.registry.subprocess.run")
156 |     @mock.patch("ctfcli.core.deployment.registry.click.secho")
157 |     @mock.patch("ctfcli.core.deployment.registry.Config")
158 |     @mock.patch("ctfcli.core.challenge.Image")
159 |     def test_fails_deployment_if_image_build_failed(
160 |         self,
161 |         mock_image_constructor: MagicMock,
162 |         mock_config_constructor: MagicMock,
163 |         mock_secho: MagicMock,
164 |         *args,
165 |         **kwargs,
166 |     ):
167 |         challenge = Challenge(self.challenge_path)
168 | 
169 |         mock_image: MagicMock = mock_image_constructor.return_value
170 |         mock_image.name = "test-challenge"
171 |         mock_image.basename = "test-challenge"
172 |         mock_image.built = False
173 |         mock_image.build.return_value = None
174 | 
175 |         mock_config_constructor.return_value = {"registry": {"username": "test", "password": "test"}}
176 | 
177 |         handler = RegistryDeploymentHandler(challenge, host="registry://registry.example.com/example-project")
178 |         result = handler.deploy()
179 | 
180 |         self.assertIsInstance(result, DeploymentResult)
181 |         self.assertFalse(result.success)
182 |         mock_secho.assert_called_once_with("Could not build the image. Please check docker output above.", fg="red")
183 | 
184 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
185 |     @mock.patch("ctfcli.core.deployment.registry.subprocess.run")
186 |     @mock.patch("ctfcli.core.deployment.registry.click.secho")
187 |     @mock.patch("ctfcli.core.deployment.registry.Config")
188 |     @mock.patch("ctfcli.core.challenge.Image")
189 |     def test_fails_deployment_if_image_push_failed(
190 |         self,
191 |         mock_image_constructor: MagicMock,
192 |         mock_config_constructor: MagicMock,
193 |         mock_secho: MagicMock,
194 |         *args,
195 |         **kwargs,
196 |     ):
197 |         challenge = Challenge(self.challenge_path)
198 | 
199 |         mock_image: MagicMock = mock_image_constructor.return_value
200 |         mock_image.name = "test-challenge"
201 |         mock_image.basename = "test-challenge"
202 |         mock_image.build.return_value = "test-challenge"
203 |         mock_image.push.return_value = None
204 | 
205 |         mock_config_constructor.return_value = {"registry": {"username": "test", "password": "test"}}
206 | 
207 |         handler = RegistryDeploymentHandler(challenge, host="registry://registry.example.com/example-project")
208 |         result = handler.deploy()
209 | 
210 |         self.assertIsInstance(result, DeploymentResult)
211 |         self.assertFalse(result.success)
212 |         mock_secho.assert_called_once_with(
213 |             "Could not push image to the registry. Please check docker output above.", fg="red"
214 |         )
215 | 
216 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
217 |     @mock.patch("ctfcli.core.deployment.registry.click.secho")
218 |     @mock.patch("ctfcli.core.deployment.registry.subprocess.run")
219 |     @mock.patch("ctfcli.core.deployment.registry.Config")
220 |     @mock.patch("ctfcli.core.challenge.Image")
221 |     def test_allows_skipping_login(
222 |         self,
223 |         mock_image_constructor: MagicMock,
224 |         mock_config_constructor: MagicMock,
225 |         mock_subprocess: MagicMock,
226 |         mock_secho: MagicMock,
227 |         *args,
228 |         **kwargs,
229 |     ):
230 |         challenge = Challenge(self.challenge_path)
231 | 
232 |         mock_image: MagicMock = mock_image_constructor.return_value
233 |         mock_image.name = "test-challenge"
234 |         mock_image.basename = "test-challenge"
235 |         mock_image.build.return_value = "test-challenge"
236 |         mock_image.push.return_value = "registry.example.com/example-project/test-challenge"
237 | 
238 |         mock_config_constructor.return_value = {"registry": {"username": "test", "password": "test"}}
239 | 
240 |         handler = RegistryDeploymentHandler(challenge, host="registry://registry.example.com/example-project")
241 |         result = handler.deploy(skip_login=True)
242 | 
243 |         self.assertIsInstance(result, DeploymentResult)
244 |         self.assertTrue(result.success)
245 | 
246 |         mock_secho.assert_called_once_with(
247 |             "Skipping registry login because of --skip-login. Make sure you are logged in to the registry.",
248 |             fg="yellow",
249 |         )
250 |         mock_subprocess.assert_not_called()
251 | 
252 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
253 |     @mock.patch("ctfcli.core.deployment.registry.click.secho")
254 |     @mock.patch("ctfcli.core.deployment.registry.subprocess.run")
255 |     @mock.patch("ctfcli.core.challenge.Image")
256 |     def test_warns_about_logging_in_with_skip_login(
257 |         self,
258 |         mock_image_constructor: MagicMock,
259 |         mock_subprocess: MagicMock,
260 |         mock_secho: MagicMock,
261 |         *args,
262 |         **kwargs,
263 |     ):
264 |         challenge = Challenge(self.challenge_path)
265 | 
266 |         mock_image: MagicMock = mock_image_constructor.return_value
267 |         mock_image.name = "test-challenge"
268 |         mock_image.basename = "test-challenge"
269 |         mock_image.build.return_value = "test-challenge"
270 |         mock_image.push.return_value = None
271 | 
272 |         mock_subprocess.side_effect = [CalledProcessError(1, "")]
273 | 
274 |         handler = RegistryDeploymentHandler(challenge, host="registry://registry.example.com/example-project")
275 |         result = handler.deploy(skip_login=True)
276 | 
277 |         self.assertIsInstance(result, DeploymentResult)
278 |         self.assertFalse(result.success)
279 |         mock_secho.assert_has_calls(
280 |             [
281 |                 call(
282 |                     "Skipping registry login because of --skip-login. Make sure you are logged in to the registry.",
283 |                     fg="yellow",
284 |                 ),
285 |                 call("Could not push image to the registry. Please check docker output above.", fg="red"),
286 |                 call(
287 |                     "Remember that you need to manually login to the docker registry when using --skip-login",
288 |                     fg="yellow",
289 |                 ),
290 |             ]
291 |         )
292 | 


--------------------------------------------------------------------------------
/tests/core/deployment/test_ssh_deployment.py:
--------------------------------------------------------------------------------
  1 | import unittest
  2 | from pathlib import Path
  3 | from subprocess import CalledProcessError
  4 | from unittest import mock
  5 | from unittest.mock import MagicMock, call
  6 | 
  7 | from ctfcli.core.challenge import Challenge
  8 | from ctfcli.core.deployment import SSHDeploymentHandler
  9 | from ctfcli.core.deployment.base import DeploymentResult
 10 | 
 11 | BASE_DIR = Path(__file__).parent.parent.parent
 12 | 
 13 | 
 14 | class TestSSHDeployment(unittest.TestCase):
 15 |     challenge_directory = BASE_DIR / "fixtures" / "challenges" / "test-challenge-dockerfile"
 16 |     challenge_path = challenge_directory / "challenge.yml"
 17 | 
 18 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
 19 |     @mock.patch.object(Path, "unlink")
 20 |     @mock.patch("ctfcli.core.deployment.ssh.subprocess.run")
 21 |     @mock.patch("ctfcli.core.deployment.ssh.click.secho")
 22 |     @mock.patch("ctfcli.core.challenge.Image")
 23 |     def test_builds_exports_and_copies_image(
 24 |         self,
 25 |         mock_image_constructor: MagicMock,
 26 |         mock_secho: MagicMock,
 27 |         mock_subprocess: MagicMock,
 28 |         mock_unlink: MagicMock,
 29 |         *args,
 30 |         **kwargs,
 31 |     ):
 32 |         challenge = Challenge(self.challenge_path)
 33 | 
 34 |         mock_image: MagicMock = mock_image_constructor.return_value
 35 |         mock_image.name = "test-challenge"
 36 |         mock_image.basename = "test-challenge"
 37 |         mock_image.build.return_value = "test-challenge"
 38 |         mock_image.export.return_value = "/tmp/test/test-challenge.tar"
 39 |         mock_image.get_exposed_port.return_value = 80
 40 | 
 41 |         handler = SSHDeploymentHandler(challenge, host="ssh://root@127.0.0.1")
 42 |         result = handler.deploy()
 43 | 
 44 |         self.assertIsInstance(result, DeploymentResult)
 45 |         self.assertTrue(result.success)
 46 |         self.assertEqual("http://127.0.0.1", result.connection_info)
 47 | 
 48 |         mock_secho.assert_not_called()
 49 |         mock_subprocess.assert_has_calls(
 50 |             [
 51 |                 call(["scp", Path("/tmp/test/test-challenge.tar"), "root@127.0.0.1:/tmp/test-challenge.tar"]),
 52 |                 call(["ssh", "root@127.0.0.1", "docker load -i /tmp/test-challenge.tar && rm /tmp/test-challenge.tar"]),
 53 |                 call(
 54 |                     [
 55 |                         "ssh",
 56 |                         "root@127.0.0.1",
 57 |                         "docker stop test-challenge 2>/dev/null; docker rm test-challenge 2>/dev/null",
 58 |                     ]
 59 |                 ),
 60 |                 call(
 61 |                     [
 62 |                         "ssh",
 63 |                         "root@127.0.0.1",
 64 |                         "docker run -d -p80:80 --name test-challenge --restart always test-challenge",
 65 |                     ]
 66 |                 ),
 67 |             ]
 68 |         )
 69 | 
 70 |         mock_unlink.assert_called_once()
 71 | 
 72 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
 73 |     @mock.patch("ctfcli.core.deployment.ssh.click.secho")
 74 |     def test_fails_deployment_if_challenge_does_not_provide_image(self, mock_secho: MagicMock, *args, **kwargs):
 75 |         challenge = Challenge(self.challenge_path, {"image": None, "host": "ssh://root@127.0.0.1"})
 76 |         handler = SSHDeploymentHandler(challenge)
 77 |         result = handler.deploy()
 78 | 
 79 |         self.assertIsInstance(result, DeploymentResult)
 80 |         self.assertFalse(result.success)
 81 |         mock_secho.assert_called_once_with("Challenge does not define an image to deploy", fg="red")
 82 | 
 83 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
 84 |     @mock.patch("ctfcli.core.deployment.ssh.click.secho")
 85 |     def test_fails_deployment_if_no_host_provided(self, mock_secho: MagicMock, *args, **kwargs):
 86 |         challenge = Challenge(self.challenge_path)
 87 |         handler = SSHDeploymentHandler(challenge)
 88 |         result = handler.deploy()
 89 | 
 90 |         self.assertIsInstance(result, DeploymentResult)
 91 |         self.assertFalse(result.success)
 92 |         mock_secho.assert_called_once_with(
 93 |             "No host provided for the deployment. Use --host, or define host in the challenge.yml file", fg="red"
 94 |         )
 95 | 
 96 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
 97 |     @mock.patch("ctfcli.core.deployment.ssh.click.secho")
 98 |     @mock.patch("ctfcli.core.challenge.Image")
 99 |     def test_fails_deployment_if_image_build_failed(
100 |         self,
101 |         mock_image_constructor: MagicMock,
102 |         mock_secho: MagicMock,
103 |         *args,
104 |         **kwargs,
105 |     ):
106 |         challenge = Challenge(self.challenge_path)
107 |         mock_image: MagicMock = mock_image_constructor.return_value
108 |         mock_image.name = "test-challenge"
109 |         mock_image.built = False
110 |         mock_image.build.return_value = None
111 | 
112 |         handler = SSHDeploymentHandler(challenge, host="ssh://root@127.0.0.1")
113 |         result = handler.deploy()
114 | 
115 |         self.assertIsInstance(result, DeploymentResult)
116 |         self.assertFalse(result.success)
117 |         mock_secho.assert_called_once_with("Could not build the image. Please check docker output above.", fg="red")
118 | 
119 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
120 |     @mock.patch("ctfcli.core.deployment.ssh.click.secho")
121 |     @mock.patch("ctfcli.core.challenge.Image")
122 |     def test_fails_deployment_if_image_export_failed(
123 |         self,
124 |         mock_image_constructor: MagicMock,
125 |         mock_secho: MagicMock,
126 |         *args,
127 |         **kwargs,
128 |     ):
129 |         challenge = Challenge(self.challenge_path)
130 | 
131 |         mock_image: MagicMock = mock_image_constructor.return_value
132 |         mock_image.name = "test-challenge"
133 |         mock_image.basename = "test-challenge"
134 |         mock_image.build.return_value = "test-challenge"
135 |         mock_image.export.return_value = None
136 | 
137 |         handler = SSHDeploymentHandler(challenge, host="ssh://root@127.0.0.1")
138 |         result = handler.deploy()
139 | 
140 |         self.assertIsInstance(result, DeploymentResult)
141 |         self.assertFalse(result.success)
142 |         mock_secho.assert_called_once_with("Could not export the image. Please check docker output above.", fg="red")
143 | 
144 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
145 |     @mock.patch("ctfcli.core.deployment.ssh.click.secho")
146 |     @mock.patch("ctfcli.core.challenge.Image")
147 |     def test_fails_deployment_if_no_exposed_port(
148 |         self,
149 |         mock_image_constructor: MagicMock,
150 |         mock_secho: MagicMock,
151 |         *args,
152 |         **kwargs,
153 |     ):
154 |         challenge = Challenge(self.challenge_path)
155 | 
156 |         mock_image: MagicMock = mock_image_constructor.return_value
157 |         mock_image.name = "test-challenge"
158 |         mock_image.basename = "test-challenge"
159 |         mock_image.build.return_value = "test-challenge"
160 |         mock_image.export.return_value = "/tmp/test/test-challenge.tar"
161 |         mock_image.get_exposed_port.return_value = None
162 | 
163 |         handler = SSHDeploymentHandler(challenge, host="ssh://root@127.0.0.1")
164 |         result = handler.deploy()
165 | 
166 |         self.assertIsInstance(result, DeploymentResult)
167 |         self.assertFalse(result.success)
168 |         mock_secho.assert_called_once_with(
169 |             "Could not resolve a port to expose. Make sure your Dockerfile EXPOSE's a port.", fg="red"
170 |         )
171 | 
172 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
173 |     @mock.patch("ctfcli.core.deployment.ssh.subprocess.run")
174 |     @mock.patch("ctfcli.core.deployment.ssh.click.secho")
175 |     @mock.patch("ctfcli.core.challenge.Image")
176 |     def test_fails_deployment_if_any_subprocess_exits(
177 |         self,
178 |         mock_image_constructor: MagicMock,
179 |         mock_secho: MagicMock,
180 |         mock_subprocess: MagicMock,
181 |         *args,
182 |         **kwargs,
183 |     ):
184 |         challenge = Challenge(self.challenge_path)
185 | 
186 |         mock_image: MagicMock = mock_image_constructor.return_value
187 |         mock_image.name = "test-challenge"
188 |         mock_image.basename = "test-challenge"
189 |         mock_image.build.return_value = "test-challenge"
190 |         mock_image.export.return_value = "/tmp/test/test-challenge.tar"
191 |         mock_image.get_exposed_port.return_value = 80
192 | 
193 |         mock_subprocess.side_effect = [CalledProcessError(1, "test-exception")]
194 | 
195 |         handler = SSHDeploymentHandler(challenge, host="ssh://root@127.0.0.1")
196 |         result = handler.deploy()
197 | 
198 |         self.assertIsInstance(result, DeploymentResult)
199 |         self.assertFalse(result.success)
200 |         mock_secho.assert_has_calls(
201 |             [
202 |                 call("Failed to deploy image!", fg="red"),
203 |                 call("Command 'test-exception' returned non-zero exit status 1.", fg="red"),
204 |             ]
205 |         )
206 | 
207 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
208 |     def test_get_connection_info_http_s(self, *args, **kwargs):
209 |         challenge = Challenge(self.challenge_path)
210 | 
211 |         handler = SSHDeploymentHandler(challenge, host="ssh://root@127.0.0.1", protocol="http")
212 |         connection_info_http = handler._get_connection_info("127.0.0.1", 8080)
213 |         self.assertEqual("http://127.0.0.1:8080", connection_info_http)
214 | 
215 |         handler = SSHDeploymentHandler(challenge, host="ssh://root@127.0.0.1", protocol="https")
216 |         connection_info_https = handler._get_connection_info("127.0.0.1", 8443)
217 |         self.assertEqual("https://127.0.0.1:8443", connection_info_https)
218 | 
219 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
220 |     def test_get_connection_info_does_not_assign_standard_ports(self, *args, **kwargs):
221 |         challenge = Challenge(self.challenge_path)
222 | 
223 |         handler = SSHDeploymentHandler(challenge, host="ssh://root@127.0.0.1", protocol="http")
224 |         connection_info_http = handler._get_connection_info("127.0.0.1", 80)
225 |         self.assertEqual("http://127.0.0.1", connection_info_http)
226 | 
227 |         handler = SSHDeploymentHandler(challenge, host="ssh://root@127.0.0.1", protocol="https")
228 |         connection_info_https = handler._get_connection_info("127.0.0.1", 443)
229 |         self.assertEqual("https://127.0.0.1", connection_info_https)
230 | 
231 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
232 |     def test_get_connection_info_tcp(self, *args, **kwargs):
233 |         challenge = Challenge(self.challenge_path)
234 | 
235 |         handler = SSHDeploymentHandler(challenge, host="ssh://root@127.0.0.1", protocol="tcp")
236 |         connection_info = handler._get_connection_info("127.0.0.1", 9001)
237 |         self.assertEqual("nc 127.0.0.1 9001", connection_info)
238 | 
239 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=challenge_directory)
240 |     def test_get_connection_info_fallback(self, *args, **kwargs):
241 |         challenge = Challenge(self.challenge_path, {"protocol": None})
242 | 
243 |         handler = SSHDeploymentHandler(challenge, host="ssh://root@127.0.0.1")
244 |         connection_info = handler._get_connection_info("127.0.0.1", 9001)
245 |         self.assertEqual("127.0.0.1", connection_info)
246 | 


--------------------------------------------------------------------------------
/tests/core/test_api.py:
--------------------------------------------------------------------------------
  1 | import unittest
  2 | from unittest import mock
  3 | from unittest.mock import MagicMock, call
  4 | 
  5 | from ctfcli.core.api import API
  6 | 
  7 | 
  8 | class MockConfigSection(dict):
  9 |     def __init__(self, data):
 10 |         super(MockConfigSection, self).__init__(data)
 11 | 
 12 |     # this is a wrong implementation but all that's necessary for this test
 13 |     def getboolean(self, key, default=None):
 14 |         if key not in self:
 15 |             return default
 16 | 
 17 |         return self[key]
 18 | 
 19 | 
 20 | class TestAPI(unittest.TestCase):
 21 |     def test_api_object_ensures_trailing_slash_on_prefix_url(self):
 22 |         test_urls = [
 23 |             "https://example.com/test/",
 24 |             "https://example.com/test",
 25 |             "https://example.com/test////",
 26 |         ]
 27 | 
 28 |         for url in test_urls:
 29 |             mock_config = {"config": MockConfigSection({"url": url, "access_token": "test"})}
 30 | 
 31 |             with mock.patch("ctfcli.core.api.Config", return_value=mock_config):
 32 |                 api = API()
 33 |                 self.assertEqual(api.prefix_url, "https://example.com/test/")
 34 | 
 35 |     @mock.patch(
 36 |         "ctfcli.core.api.Config",
 37 |         return_value=MockConfigSection(
 38 |             {"config": MockConfigSection({"url": "https://example.com/test", "access_token": "test"})}
 39 |         ),
 40 |     )
 41 |     @mock.patch("ctfcli.core.api.Session.request")
 42 |     def test_api_object_request_strips_preceding_slash_from_url_path(self, mock_request: MagicMock, *args, **kwargs):
 43 |         api = API()
 44 |         api.request("GET", "/path")
 45 |         api.request("GET", "path")
 46 | 
 47 |         mock_request.assert_has_calls(
 48 |             [
 49 |                 call("GET", "https://example.com/test/path", headers={"Content-Type": "application/json"}),
 50 |                 call("GET", "https://example.com/test/path", headers={"Content-Type": "application/json"}),
 51 |             ]
 52 |         )
 53 | 
 54 |     @mock.patch(
 55 |         "ctfcli.core.api.Config",
 56 |         return_value={"config": MockConfigSection({"url": "https://example.com/test", "access_token": "test"})},
 57 |     )
 58 |     @mock.patch("ctfcli.core.api.Session.request")
 59 |     def test_api_object_request_assigns_prefix_url(self, mock_request: MagicMock, *args, **kwargs):
 60 |         api = API()
 61 |         api.request("GET", "path")
 62 |         mock_request.assert_called_once_with(
 63 |             "GET", "https://example.com/test/path", headers={"Content-Type": "application/json"}
 64 |         )
 65 | 
 66 |     def test_api_object_assigns_ssl_verify(self, *args, **kwargs):
 67 |         with mock.patch(
 68 |             "ctfcli.core.api.Config",
 69 |             return_value={
 70 |                 "config": MockConfigSection(
 71 |                     {
 72 |                         "url": "https://example.com/test",
 73 |                         "access_token": "test",
 74 |                     }
 75 |                 )
 76 |             },
 77 |         ):
 78 |             api = API()
 79 |             # expect the default to be true
 80 |             self.assertTrue(api.verify)
 81 | 
 82 |         with mock.patch(
 83 |             "ctfcli.core.api.Config",
 84 |             return_value={
 85 |                 "config": MockConfigSection(
 86 |                     {
 87 |                         "url": "https://example.com/test",
 88 |                         "access_token": "test",
 89 |                         "ssl_verify": True,
 90 |                     }
 91 |                 )
 92 |             },
 93 |         ):
 94 |             api = API()
 95 |             self.assertTrue(api.verify)
 96 | 
 97 |         with mock.patch(
 98 |             "ctfcli.core.api.Config",
 99 |             return_value={
100 |                 "config": MockConfigSection(
101 |                     {
102 |                         "url": "https://example.com/test",
103 |                         "access_token": "test",
104 |                         "ssl_verify": False,
105 |                     }
106 |                 )
107 |             },
108 |         ):
109 |             api = API()
110 |             self.assertFalse(api.verify)
111 | 
112 |     @mock.patch("ctfcli.core.api.Config")
113 |     def test_api_expects_value_error(self, mock_config_constructor: MagicMock):
114 |         mock_config_constructor.return_value = {
115 |             "config": MagicMock(
116 |                 getboolean=MagicMock(side_effect=ValueError("Invalid boolean value")),
117 |                 get=MagicMock(return_value="/tmp/certificate"),
118 |             )
119 |         }
120 | 
121 |         api = API()
122 |         self.assertEqual("/tmp/certificate", api.verify)
123 | 
124 |     @mock.patch(
125 |         "ctfcli.core.api.Config",
126 |         return_value={
127 |             "config": MockConfigSection(
128 |                 {
129 |                     "url": "https://example.com/test",
130 |                     "access_token": "test",
131 |                 }
132 |             )
133 |         },
134 |     )
135 |     def test_api_object_assigns_headers(self, *args, **kwargs):
136 |         api = API()
137 | 
138 |         self.assertIn("Authorization", api.headers)
139 |         self.assertEqual("Token test", api.headers["Authorization"])
140 | 
141 |     @mock.patch(
142 |         "ctfcli.core.api.Config",
143 |         return_value={
144 |             "config": MockConfigSection(
145 |                 {
146 |                     "url": "https://example.com/test",
147 |                     "access_token": "test",
148 |                 }
149 |             ),
150 |             "cookies": MockConfigSection({"test-cookie": "test-value"}),
151 |         },
152 |     )
153 |     def test_api_object_assigns_cookies(self, *args, **kwargs):
154 |         api = API()
155 |         self.assertIn("test-cookie", api.cookies)
156 |         self.assertEqual(api.cookies["test-cookie"], "test-value")
157 | 
158 |     @mock.patch(
159 |         "ctfcli.core.api.Config",
160 |         return_value={
161 |             "config": MockConfigSection(
162 |                 {
163 |                     "url": "https://example.com/",
164 |                     "access_token": "test",
165 |                 }
166 |             ),
167 |         },
168 |     )
169 |     @mock.patch("ctfcli.core.api.Session.request")
170 |     def test_request_does_not_override_form_data_content_type(self, mock_request: MagicMock, *args, **kwargs):
171 |         api = API()
172 |         api.request("GET", "/test", data="some-file")
173 |         mock_request.assert_called_once_with("GET", "https://example.com/test", data="some-file")
174 | 


--------------------------------------------------------------------------------
/tests/core/test_config.py:
--------------------------------------------------------------------------------
  1 | import json
  2 | import os
  3 | import tempfile
  4 | import unittest
  5 | from pathlib import Path
  6 | from unittest import mock
  7 | from unittest.mock import MagicMock
  8 | 
  9 | from ctfcli.core.config import Config
 10 | from ctfcli.core.exceptions import ProjectNotInitialized
 11 | 
 12 | BASE_DIR = Path(__file__).parent.parent
 13 | 
 14 | 
 15 | class TestConfig(unittest.TestCase):
 16 |     minimal_challenge_cwd = BASE_DIR / "fixtures" / "challenges" / "test-challenge-minimal"
 17 | 
 18 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=Path(tempfile.mkdtemp()))
 19 |     def test_raises_if_config_is_not_found(self, *args, **kwargs):
 20 |         with self.assertRaises(ProjectNotInitialized):
 21 |             Config()
 22 | 
 23 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=minimal_challenge_cwd)
 24 |     def test_determines_project_path(self, *args, **kwargs):
 25 |         config = Config()
 26 |         expected_project_path = BASE_DIR / "fixtures" / "challenges"
 27 |         self.assertEqual(expected_project_path, config.project_path)
 28 |         self.assertEqual(expected_project_path, config.get_project_path())
 29 | 
 30 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=minimal_challenge_cwd)
 31 |     def test_determines_base_path(self, *args, **kwargs):
 32 |         config = Config()
 33 |         expected_base_path = BASE_DIR.parent / "ctfcli"
 34 |         self.assertEqual(expected_base_path, config.base_path)
 35 |         self.assertEqual(expected_base_path, config.get_base_path())
 36 | 
 37 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=minimal_challenge_cwd)
 38 |     def test_determines_config_path(self, *args, **kwargs):
 39 |         config = Config()
 40 |         expected_config_path = BASE_DIR / "fixtures" / "challenges" / ".ctf" / "config"
 41 |         self.assertEqual(expected_config_path, config.config_path)
 42 |         self.assertEqual(expected_config_path, config.get_config_path())
 43 | 
 44 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=minimal_challenge_cwd)
 45 |     @mock.patch("ctfcli.core.config.configparser.ConfigParser")
 46 |     def test_reads_config(self, mock_configparser: MagicMock, *args, **kwargs):
 47 |         Config()
 48 |         expected_config_path = BASE_DIR / "fixtures" / "challenges" / ".ctf" / "config"
 49 |         mock_configparser.return_value.read.assert_called_once_with(expected_config_path)
 50 | 
 51 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=minimal_challenge_cwd)
 52 |     @mock.patch("ctfcli.core.config.configparser.ConfigParser")
 53 |     def test_writes_config(self, mock_configparser: MagicMock, *args, **kwargs):
 54 |         config = Config()
 55 | 
 56 |         with tempfile.NamedTemporaryFile(delete=True) as tmp_config:
 57 |             config.write(tmp_config)
 58 |             mock_configparser.return_value.write.assert_called_once_with(tmp_config)
 59 | 
 60 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=minimal_challenge_cwd)
 61 |     def test_returns_correct_json_representation(self, *args, **kwargs):
 62 |         config = Config()
 63 | 
 64 |         expected_config = {
 65 |             "config": {"access_token": "deadbeef", "url": "https://example.com/"},
 66 |             "challenges": {
 67 |                 "test-challenge-dockerfile": "user@host:example/test-challenge-dockerfile.git",
 68 |                 "test-challenge-files": "user@host:example/test-challenge-files.git",
 69 |                 "test-challenge-full": "user@host:example/test-challenge-full.git",
 70 |                 "test-challenge-minimal": "user@host:example/test-challenge-minimal.git",
 71 |             },
 72 |         }
 73 | 
 74 |         config_data = json.loads(config.as_json())
 75 |         self.assertEqual(expected_config, config_data)
 76 | 
 77 |         config_data_pretty = json.loads(config.as_json(pretty=True))
 78 |         self.assertEqual(expected_config, config_data_pretty)
 79 | 
 80 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=minimal_challenge_cwd)
 81 |     def test_overloads_getitem(self, *args, **kwargs):
 82 |         config = Config()
 83 | 
 84 |         # test that config can be directly accessed like a dictionary
 85 |         self.assertEqual(config["config"]["url"], "https://example.com/")
 86 |         self.assertEqual(
 87 |             config["challenges"]["test-challenge-minimal"],
 88 |             "user@host:example/test-challenge-minimal.git",
 89 |         )
 90 | 
 91 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=minimal_challenge_cwd)
 92 |     def test_overloads_contains(self, *args, **kwargs):
 93 |         config = Config()
 94 |         # test that config can be queried with 'in'
 95 |         self.assertTrue("challenges" in config)
 96 | 
 97 |     def test_get_data_path_returns_path(self):
 98 |         data_path = Config.get_data_path()
 99 |         self.assertIsInstance(data_path, Path)
100 | 
101 |     def test_get_templates_path_returns_path(self):
102 |         templates_path = Config.get_templates_path()
103 |         self.assertIsInstance(templates_path, Path)
104 | 
105 |     @mock.patch("ctfcli.core.config.appdirs.user_data_dir")
106 |     def test_get_data_path_calls_appdirs(self, mock_user_data_path: MagicMock):
107 |         Config.get_data_path()
108 |         mock_user_data_path.assert_called_once_with(appname="ctfcli")
109 | 
110 |     @mock.patch(
111 |         "ctfcli.core.config.Config.get_data_path",
112 |         return_value=Path("/tmp/test/ctfcli-data"),
113 |     )
114 |     @mock.patch.object(Path, "mkdir")
115 |     @mock.patch.object(Path, "exists")
116 |     def test_get_templates_path(self, mock_exists: MagicMock, mock_mkdir: MagicMock, *args, **kwargs):
117 |         expected_templates_path = Path("/tmp/test/ctfcli-data/templates")
118 |         mock_exists.return_value = False
119 | 
120 |         templates_path = Config.get_templates_path()
121 | 
122 |         self.assertEqual(templates_path, expected_templates_path)
123 |         mock_mkdir.assert_called_once()
124 | 
125 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=minimal_challenge_cwd)
126 |     def test_get_pages_path_returns_path(self, *args, **kwargs):
127 |         pages_path = Config.get_pages_path()
128 |         self.assertIsInstance(pages_path, Path)
129 | 
130 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=minimal_challenge_cwd)
131 |     def test_get_pages_path(self, *args, **kwargs):
132 |         expected_pages_path = BASE_DIR / "fixtures" / "challenges" / "pages"
133 |         pages_path = Config.get_pages_path()
134 |         self.assertEqual(expected_pages_path, pages_path)
135 | 
136 |     @mock.patch(
137 |         "ctfcli.core.config.Config.get_project_path",
138 |         return_value=Path("/tmp/test/ctfcli-project"),
139 |     )
140 |     @mock.patch.object(Path, "mkdir")
141 |     @mock.patch.object(Path, "exists")
142 |     def test_get_pages_path_creates_directory(self, mock_exists: MagicMock, mock_mkdir: MagicMock, *args, **kwargs):
143 |         expected_pages_path = Path("/tmp/test/ctfcli-project/pages")
144 |         mock_exists.return_value = False
145 | 
146 |         pages_path = Config.get_pages_path()
147 | 
148 |         self.assertEqual(pages_path, expected_pages_path)
149 |         mock_mkdir.assert_called_once()
150 | 
151 |     @mock.patch("ctfcli.core.config.Path.cwd", return_value=minimal_challenge_cwd)
152 |     @mock.patch(
153 |         "ctfcli.core.config.Config.get_data_path",
154 |         return_value=Path("/tmp/test/ctfcli-data"),
155 |     )
156 |     def test_get_plugins_path(self, *args, **kwargs):
157 |         expected_plugins_path = Path("/tmp/test/ctfcli-data") / "plugins"
158 |         pages_path = Config.get_plugins_path()
159 |         self.assertEqual(expected_plugins_path, pages_path)
160 | 
161 |     @mock.patch(
162 |         "ctfcli.core.config.Config.get_data_path",
163 |         return_value=Path("/tmp/test/ctfcli-data"),
164 |     )
165 |     @mock.patch.object(Path, "mkdir")
166 |     @mock.patch.object(Path, "exists")
167 |     def test_get_plugins_path_creates_directory(self, mock_exists: MagicMock, mock_mkdir: MagicMock, *args, **kwargs):
168 |         expected_plugins_path = Path("/tmp/test/ctfcli-data/plugins")
169 |         mock_exists.return_value = False
170 | 
171 |         plugins_path = Config.get_plugins_path()
172 | 
173 |         self.assertEqual(expected_plugins_path, plugins_path)
174 |         mock_mkdir.assert_called_once()
175 | 
176 |     @mock.patch.dict(os.environ, {"CTFCLI_PLUGIN_PATH": "/tmp/test/custom-plugins-directory"})
177 |     @mock.patch.object(Path, "exists")
178 |     def test_get_plugins_path_uses_overriden_directory(self, mock_exists: MagicMock, *args, **kwargs):
179 |         expected_plugins_path = Path("/tmp/test/custom-plugins-directory")
180 |         mock_exists.return_value = True
181 | 
182 |         plugins_path = Config.get_plugins_path()
183 |         self.assertEqual(expected_plugins_path, plugins_path)
184 | 
185 |     @mock.patch.dict(os.environ, {"CTFCLI_PLUGIN_PATH": "custom-plugins-directory"})
186 |     @mock.patch.object(Path, "exists")
187 |     def test_get_plugins_path_accepts_relative_directory_override(self, mock_exists: MagicMock, *args, **kwargs):
188 |         expected_plugins_path = BASE_DIR.parent / "ctfcli" / "custom-plugins-directory"
189 |         mock_exists.return_value = True
190 | 
191 |         plugins_path = Config.get_plugins_path()
192 | 
193 |         self.assertEqual(expected_plugins_path, plugins_path)
194 | 


--------------------------------------------------------------------------------
/tests/core/test_exceptions.py:
--------------------------------------------------------------------------------
 1 | import unittest
 2 | from unittest import mock
 3 | from unittest.mock import MagicMock, call
 4 | 
 5 | from ctfcli.core.exceptions import LintException
 6 | 
 7 | 
 8 | class TestLintException(unittest.TestCase):
 9 |     @mock.patch("ctfcli.core.exceptions.click.echo")
10 |     @mock.patch("ctfcli.core.exceptions.click.secho")
11 |     def test_print_summary(self, mock_secho: MagicMock, mock_echo: MagicMock):
12 |         test_issues = {
13 |             "fields": [
14 |                 "challenge.yml is missing required field: author",
15 |                 "challenge.yml is missing required field: name",
16 |                 "challenge.yml is missing required field: value",
17 |             ],
18 |             "dockerfile": ["Dockerfile exists but image field does not point to it", "Dockerfile is missing EXPOSE"],
19 |             "hadolint": ["-:1 DL3006 warning: Always tag the version of an image explicitly"],
20 |             "files": [
21 |                 "Challenge file 'files/test-file.png' specified, but not found at /challenge/files/test-file.png"
22 |             ],
23 |         }
24 | 
25 |         with self.assertRaises(LintException) as e:
26 |             raise LintException(issues=test_issues)
27 | 
28 |         self.assertDictEqual(test_issues, e.exception.issues)
29 |         e.exception.print_summary()
30 | 
31 |         mock_secho.assert_has_calls(
32 |             [
33 |                 call("Fields:", fg="yellow"),
34 |                 call("Dockerfile:", fg="yellow"),
35 |                 call("Hadolint:", fg="yellow"),
36 |                 call("Files:", fg="yellow"),
37 |             ]
38 |         )
39 | 
40 |         mock_echo.assert_has_calls(
41 |             [
42 |                 call(" - challenge.yml is missing required field: author"),
43 |                 call(" - challenge.yml is missing required field: name"),
44 |                 call(" - challenge.yml is missing required field: value"),
45 |                 call(),
46 |                 call(" - Dockerfile exists but image field does not point to it"),
47 |                 call(" - Dockerfile is missing EXPOSE"),
48 |                 call(),
49 |                 call("-:1 DL3006 warning: Always tag the version of an image explicitly"),
50 |                 call(
51 |                     " - Challenge file 'files/test-file.png' specified, "
52 |                     "but not found at /challenge/files/test-file.png"
53 |                 ),
54 |                 call(),
55 |             ]
56 |         )
57 | 


--------------------------------------------------------------------------------
/tests/core/test_image.py:
--------------------------------------------------------------------------------
  1 | import unittest
  2 | from pathlib import Path
  3 | from unittest import mock
  4 | from unittest.mock import MagicMock, call
  5 | 
  6 | from ctfcli.core.image import Image
  7 | 
  8 | BASE_DIR = Path(__file__).parent.parent
  9 | 
 10 | 
 11 | class TestImage(unittest.TestCase):
 12 |     def test_assigns_attributes(self):
 13 |         build_path = BASE_DIR / "fixtures" / "challenges" / "test-challenge-dockerfile"
 14 |         image = Image("test-challenge", build_path)
 15 | 
 16 |         self.assertEqual(image.name, "test-challenge")
 17 |         self.assertEqual(image.build_path, build_path)
 18 |         self.assertFalse(image.built)
 19 | 
 20 |     def test_extracts_correct_basename(self):
 21 |         image_names = [
 22 |             "test-challenge",
 23 |             "test-challenge:latest",
 24 |             "test-challenge:1.0.0",
 25 |             "registry.ctfd.io/example-project/test-challenge",
 26 |             "registry.ctfd.io/example-project/test-challenge:latest",
 27 |             "registry.ctfd.io/example-project/test-challenge:1.0.0",
 28 |             "ghcr.io/example-org/test-challenge",
 29 |             "ghcr.io/example-org/test-challenge:latest",
 30 |             "ghcr.io/example-org/test-challenge:1.0.0",
 31 |             "library/test-challenge",
 32 |             "library/test-challenge:latest",
 33 |             "library/test-challenge:1.0.0",
 34 |         ]
 35 | 
 36 |         for name in image_names:
 37 |             image = Image(name)
 38 |             self.assertEqual(image.basename, "test-challenge")
 39 | 
 40 |     def test_accepts_path_as_string_and_pathlike(self):
 41 |         build_path = BASE_DIR / "fixtures" / "challenges" / "test-challenge-dockerfile"
 42 |         image = Image("test-challenge", build_path)
 43 |         self.assertEqual(image.build_path, build_path)
 44 | 
 45 |         build_path_string = str(build_path)
 46 |         image = Image("test-challenge", build_path_string)
 47 |         self.assertEqual(image.build_path, build_path)
 48 | 
 49 |     @mock.patch("ctfcli.core.image.subprocess.call", return_value=0)
 50 |     def test_build(self, mock_call: MagicMock):
 51 |         build_path = BASE_DIR / "fixtures" / "challenges" / "test-challenge-dockerfile"
 52 |         image = Image("test-challenge", build_path)
 53 |         self.assertFalse(image.built)
 54 | 
 55 |         image_name = image.build()
 56 | 
 57 |         self.assertTrue(image.built)
 58 |         self.assertEqual(image_name, "test-challenge")
 59 |         mock_call.assert_called_once_with(
 60 |             ["docker", "build", "--load", "-t", "test-challenge", "."], cwd=build_path.absolute()
 61 |         )
 62 | 
 63 |     @mock.patch("ctfcli.core.image.subprocess.call", return_value=1)
 64 |     def test_build_returns_none_if_failed(self, mock_call: MagicMock):
 65 |         build_path = BASE_DIR / "fixtures" / "challenges" / "test-challenge-dockerfile"
 66 |         image = Image("test-challenge", build_path)
 67 |         self.assertFalse(image.built)
 68 | 
 69 |         image_name = image.build()
 70 | 
 71 |         self.assertFalse(image.built)
 72 |         self.assertIsNone(image_name)
 73 |         mock_call.assert_called_once_with(
 74 |             ["docker", "build", "--load", "-t", "test-challenge", "."], cwd=build_path.absolute()
 75 |         )
 76 | 
 77 |     @mock.patch("ctfcli.core.image.subprocess.call", return_value=0)
 78 |     def test_push_built_image(self, mock_call: MagicMock):
 79 |         build_path = BASE_DIR / "fixtures" / "challenges" / "test-challenge-dockerfile"
 80 |         image = Image("test-challenge", build_path)
 81 |         self.assertFalse(image.built)
 82 | 
 83 |         image_name = image.build()
 84 |         image_location = image.push("registry.ctfd.io/example-project/test-challenge")
 85 | 
 86 |         self.assertEqual("test-challenge", image_name)
 87 |         self.assertEqual("registry.ctfd.io/example-project/test-challenge", image_location)
 88 |         self.assertTrue(image.built)
 89 | 
 90 |         mock_call.assert_has_calls(
 91 |             [
 92 |                 call(
 93 |                     [
 94 |                         "docker",
 95 |                         "tag",
 96 |                         "test-challenge",
 97 |                         "registry.ctfd.io/example-project/test-challenge",
 98 |                     ]
 99 |                 ),
100 |                 call(
101 |                     [
102 |                         "docker",
103 |                         "push",
104 |                         "registry.ctfd.io/example-project/test-challenge",
105 |                     ]
106 |                 ),
107 |             ]
108 |         )
109 | 
110 |     # mock successful build but failed push
111 |     @mock.patch("ctfcli.core.image.subprocess.call", side_effect=[0, 1, 1])
112 |     def test_push_returns_none_if_failed(self, mock_call: MagicMock):
113 |         build_path = BASE_DIR / "fixtures" / "challenges" / "test-challenge-dockerfile"
114 |         image = Image("test-challenge", build_path)
115 |         self.assertFalse(image.built)
116 | 
117 |         image_name = image.build()
118 |         image_location = image.push("registry.ctfd.io/example-project/test-challenge")
119 | 
120 |         self.assertEqual("test-challenge", image_name)
121 |         self.assertIsNone(image_location)
122 |         self.assertTrue(image.built)
123 | 
124 |         mock_call.assert_has_calls(
125 |             [
126 |                 call(
127 |                     [
128 |                         "docker",
129 |                         "tag",
130 |                         "test-challenge",
131 |                         "registry.ctfd.io/example-project/test-challenge",
132 |                     ]
133 |                 ),
134 |                 call(
135 |                     [
136 |                         "docker",
137 |                         "push",
138 |                         "registry.ctfd.io/example-project/test-challenge",
139 |                     ]
140 |                 ),
141 |             ]
142 |         )
143 | 
144 |     @mock.patch("ctfcli.core.image.subprocess.call", return_value=0)
145 |     def test_builds_image_before_push(self, mock_call: MagicMock):
146 |         build_path = BASE_DIR / "fixtures" / "challenges" / "test-challenge-dockerfile"
147 |         image = Image("test-challenge", build_path)
148 |         self.assertFalse(image.built)
149 | 
150 |         image_location = image.push("registry.ctfd.io/example-project/test-challenge")
151 |         self.assertEqual("registry.ctfd.io/example-project/test-challenge", image_location)
152 |         self.assertTrue(image.built)
153 | 
154 |         mock_call.assert_has_calls(
155 |             [
156 |                 call(
157 |                     ["docker", "build", "--load", "-t", "test-challenge", "."],
158 |                     cwd=build_path.absolute(),
159 |                 ),
160 |                 call(
161 |                     [
162 |                         "docker",
163 |                         "tag",
164 |                         "test-challenge",
165 |                         "registry.ctfd.io/example-project/test-challenge",
166 |                     ]
167 |                 ),
168 |                 call(
169 |                     [
170 |                         "docker",
171 |                         "push",
172 |                         "registry.ctfd.io/example-project/test-challenge",
173 |                     ]
174 |                 ),
175 |             ]
176 |         )
177 | 
178 |     @mock.patch("ctfcli.core.image.subprocess.call", return_value=0)
179 |     def test_export_built_image(self, mock_call: MagicMock):
180 |         build_path = BASE_DIR / "fixtures" / "challenges" / "test-challenge-dockerfile"
181 |         image = Image("test-challenge", build_path)
182 |         self.assertFalse(image.built)
183 | 
184 |         image.build()
185 | 
186 |         mock_named_temporary_file = MagicMock()
187 |         mock_named_temporary_file.name = "/tmp/test-challenge.docker.tar"
188 | 
189 |         with mock.patch(
190 |             "ctfcli.core.image.tempfile.NamedTemporaryFile",
191 |             return_value=mock_named_temporary_file,
192 |         ):
193 |             export_path = image.export()
194 | 
195 |         self.assertTrue(image.built)
196 |         self.assertEqual(export_path, "/tmp/test-challenge.docker.tar")
197 |         mock_call.assert_has_calls(
198 |             [
199 |                 call(
200 |                     [
201 |                         "docker",
202 |                         "save",
203 |                         "--output",
204 |                         "/tmp/test-challenge.docker.tar",
205 |                         "test-challenge",
206 |                     ]
207 |                 )
208 |             ]
209 |         )
210 | 
211 |     @mock.patch("ctfcli.core.image.subprocess.call", return_value=0)
212 |     def test_builds_image_before_export(self, mock_call: MagicMock):
213 |         build_path = BASE_DIR / "fixtures" / "challenges" / "test-challenge-dockerfile"
214 |         image = Image("test-challenge", build_path)
215 |         self.assertFalse(image.built)
216 | 
217 |         mock_named_temporary_file = MagicMock()
218 |         mock_named_temporary_file.name = "/tmp/test-challenge.docker.tar"
219 | 
220 |         with mock.patch(
221 |             "ctfcli.core.image.tempfile.NamedTemporaryFile",
222 |             return_value=mock_named_temporary_file,
223 |         ):
224 |             export_path = image.export()
225 | 
226 |         self.assertTrue(image.built)
227 |         self.assertEqual(export_path, "/tmp/test-challenge.docker.tar")
228 |         mock_call.assert_has_calls(
229 |             [
230 |                 call(
231 |                     ["docker", "build", "--load", "-t", "test-challenge", "."],
232 |                     cwd=build_path.absolute(),
233 |                 ),
234 |                 call(
235 |                     [
236 |                         "docker",
237 |                         "save",
238 |                         "--output",
239 |                         "/tmp/test-challenge.docker.tar",
240 |                         "test-challenge",
241 |                     ]
242 |                 ),
243 |             ]
244 |         )
245 | 
246 |     @mock.patch("ctfcli.core.image.subprocess.call")
247 |     @mock.patch("ctfcli.core.image.subprocess.check_output", return_value='{"80/tcp":{}}')
248 |     def test_get_exposed_port(self, mock_check_output: MagicMock, *args, **kwargs):
249 |         build_path = BASE_DIR / "fixtures" / "challenges" / "test-challenge-dockerfile"
250 |         image = Image("test-challenge", build_path)
251 |         self.assertFalse(image.built)
252 | 
253 |         exposed_port = image.get_exposed_port()
254 |         self.assertEqual("80", exposed_port)
255 |         mock_check_output.assert_has_calls(
256 |             [
257 |                 call(
258 |                     [
259 |                         "docker",
260 |                         "inspect",
261 |                         "--format={{json .Config.ExposedPorts}}",
262 |                         "test-challenge",
263 |                     ]
264 |                 )
265 |             ]
266 |         )
267 | 
268 |     @mock.patch("ctfcli.core.image.subprocess.call")
269 |     @mock.patch(
270 |         "ctfcli.core.image.subprocess.check_output",
271 |         return_value='{"80/tcp":{},"8000/tcp":{}}',
272 |     )
273 |     def test_get_exposed_port_returns_first_port_if_multiple_exposed(
274 |         self, mock_check_output: MagicMock, *args, **kwargs
275 |     ):
276 |         build_path = BASE_DIR / "fixtures" / "challenges" / "test-challenge-dockerfile"
277 |         image = Image("test-challenge", build_path)
278 |         self.assertFalse(image.built)
279 | 
280 |         exposed_port = image.get_exposed_port()
281 |         self.assertEqual("80", exposed_port)
282 |         mock_check_output.assert_has_calls(
283 |             [
284 |                 call(
285 |                     [
286 |                         "docker",
287 |                         "inspect",
288 |                         "--format={{json .Config.ExposedPorts}}",
289 |                         "test-challenge",
290 |                     ]
291 |                 )
292 |             ]
293 |         )
294 | 
295 |     @mock.patch("ctfcli.core.image.subprocess.call")
296 |     @mock.patch("ctfcli.core.image.subprocess.check_output", return_value="null")
297 |     def test_get_exposed_port_returns_none_if_no_ports_exposed(self, mock_check_output: MagicMock, *args, **kwargs):
298 |         build_path = BASE_DIR / "fixtures" / "challenges" / "test-challenge-dockerfile"
299 |         image = Image("test-challenge", build_path)
300 |         self.assertFalse(image.built)
301 | 
302 |         exposed_port = image.get_exposed_port()
303 |         self.assertIsNone(exposed_port)
304 |         mock_check_output.assert_has_calls(
305 |             [
306 |                 call(
307 |                     [
308 |                         "docker",
309 |                         "inspect",
310 |                         "--format={{json .Config.ExposedPorts}}",
311 |                         "test-challenge",
312 |                     ]
313 |                 )
314 |             ]
315 |         )
316 | 
317 |     @mock.patch("ctfcli.core.image.subprocess.call")
318 |     def test_pull(self, mock_call: MagicMock):
319 |         image_names = [
320 |             "test-challenge",
321 |             "registry.ctfd.io/example-project/test-challenge",
322 |             "ghcr.io/example-org/test-challenge",
323 |             "library/test-challenge",
324 |             "test-challenge:latest",
325 |             "registry.ctfd.io/example-project/test-challenge:latest",
326 |             "ghcr.io/example-org/test-challenge:latest",
327 |             "library/test-challenge:latest",
328 |         ]
329 | 
330 |         for image_name in image_names:
331 |             image = Image(image_name)
332 |             image.pull()
333 |             self.assertEqual(image_name, image.name)
334 |             mock_call.assert_called_with(["docker", "pull", image_name])
335 | 


--------------------------------------------------------------------------------
/tests/core/test_plugins.py:
--------------------------------------------------------------------------------
 1 | import unittest
 2 | from pathlib import Path
 3 | from unittest import mock
 4 | from unittest.mock import MagicMock, call
 5 | 
 6 | from ctfcli.core.config import Config
 7 | from ctfcli.core.plugins import load_plugins
 8 | 
 9 | 
10 | class TestPlugins(unittest.TestCase):
11 |     @mock.patch.object(Config, "get_plugins_path")
12 |     @mock.patch("ctfcli.core.plugins.importlib.import_module")
13 |     def test_load_plugins(self, mock_import: MagicMock, mock_plugins_path: MagicMock):
14 |         mock_plugins_path.return_value = MagicMock()
15 |         mock_plugins_path.return_value.absolute.return_value = Path("/tmp/test")
16 |         mock_plugins_path.return_value.iterdir.return_value = [Path("/tmp/test/test_plugin")]
17 | 
18 |         test_commands = {"challenge": None, "pages": None}
19 |         load_plugins(test_commands)
20 | 
21 |         mock_import.assert_has_calls([call("test_plugin")])
22 |         mock_import.return_value.load.assert_called_once_with(test_commands)
23 | 


--------------------------------------------------------------------------------
/tests/fixtures/challenges/.ctf/config:
--------------------------------------------------------------------------------
 1 | [config]
 2 | url = https://example.com/
 3 | access_token = deadbeef
 4 | 
 5 | [challenges]
 6 | test-challenge-minimal = user@host:example/test-challenge-minimal.git
 7 | test-challenge-full = user@host:example/test-challenge-full.git
 8 | test-challenge-files = user@host:example/test-challenge-files.git
 9 | test-challenge-dockerfile = user@host:example/test-challenge-dockerfile.git
10 | 
11 | 


--------------------------------------------------------------------------------
/tests/fixtures/challenges/pages/html-page.html:
--------------------------------------------------------------------------------
1 | ---
2 | auth_required: false
3 | draft: false
4 | hidden: false
5 | route: html-page
6 | title: HTML Page
7 | ---
8 | 
9 | <h1>Hello World!</h1>


--------------------------------------------------------------------------------
/tests/fixtures/challenges/pages/markdown-page.md:
--------------------------------------------------------------------------------
1 | ---
2 | route: markdown-page
3 | title: Markdown Page
4 | draft: true
5 | hidden: true
6 | auth_required: true
7 | ---
8 | 
9 | # Hello World!


--------------------------------------------------------------------------------
/tests/fixtures/challenges/pages/nested/html-page.htm:
--------------------------------------------------------------------------------
1 | ---
2 | route: nested-html-page
3 | title: Nested HTML Page
4 | draft: false
5 | hidden: false
6 | auth_required: false
7 | ---
8 | 
9 | <h1>Hello Nested!</h1>


--------------------------------------------------------------------------------
/tests/fixtures/challenges/test-challenge-dockerfile/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM nginx:mainline-alpine
2 | 
3 | WORKDIR /usr/share/nginx/html
4 | COPY src/ .
5 | 
6 | EXPOSE 80
7 | 


--------------------------------------------------------------------------------
/tests/fixtures/challenges/test-challenge-dockerfile/challenge.yml:
--------------------------------------------------------------------------------
 1 | name: Test Challenge
 2 | category: New Test
 3 | description: New Test Description
 4 | attribution: New Test Attribution
 5 | value: 150
 6 | author: Test
 7 | type: standard
 8 | state: hidden
 9 | image: .
10 | protocol: http
11 | 


--------------------------------------------------------------------------------
/tests/fixtures/challenges/test-challenge-dockerfile/src/index.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="UTF-8">
 5 |     <meta name="viewport"
 6 |           content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
 7 |     <meta http-equiv="X-UA-Compatible" content="ie=edge">
 8 |     <title>Hello Test!</title>
 9 | </head>
10 | <body>
11 |     <h1>Hello Test!</h1>
12 | </body>
13 | </html>


--------------------------------------------------------------------------------
/tests/fixtures/challenges/test-challenge-files/challenge.yml:
--------------------------------------------------------------------------------
 1 | name: Test Challenge
 2 | category: New Test
 3 | description: New Test Description
 4 | attribution: New Test Attribution
 5 | value: 150
 6 | author: Test
 7 | type: standard
 8 | state: hidden
 9 | 
10 | files:
11 |   - files/test.png
12 |   - files/test.pdf
13 | 


--------------------------------------------------------------------------------
/tests/fixtures/challenges/test-challenge-files/files/flag.txt:
--------------------------------------------------------------------------------
1 | Whoopsie: flag{test-flag}


--------------------------------------------------------------------------------
/tests/fixtures/challenges/test-challenge-files/files/test.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CTFd/ctfcli/c5abdd499bc9112c6832e047aa1c77b3052de05f/tests/fixtures/challenges/test-challenge-files/files/test.pdf


--------------------------------------------------------------------------------
/tests/fixtures/challenges/test-challenge-files/files/test.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CTFd/ctfcli/c5abdd499bc9112c6832e047aa1c77b3052de05f/tests/fixtures/challenges/test-challenge-files/files/test.png


--------------------------------------------------------------------------------
/tests/fixtures/challenges/test-challenge-full/challenge.yml:
--------------------------------------------------------------------------------
 1 | name: Test Challenge
 2 | category: Test
 3 | description: Test Description
 4 | attribution: Test Attribution
 5 | value: 150
 6 | author: Test
 7 | type: standard
 8 | state: visible
 9 | attempts: 5
10 | connection_info: https://example.com
11 | 
12 | flags:
13 |     - "flag{test-flag}"
14 |     - type: static
15 |       content: "flag{test-static}"
16 |       data: case_insensitive
17 |     - type: regex
18 |       content: "flag{test-regex-.*}"
19 |       data: case_insensitive
20 | 
21 | topics:
22 |   - topic-1
23 |   - topic-2
24 | 
25 | tags:
26 |   - tag-1
27 |   - tag-2
28 | 
29 | files:
30 |   - files/test.png
31 |   - files/test.pdf
32 | 
33 | hints:
34 |   - free hint
35 |   - content: paid hint
36 |     cost: 100
37 | 
38 | requirements:
39 |   - 1
40 |   - Other Test Challenge
41 | 
42 | extra:
43 |   extra_property: extra_property_value
44 | 


--------------------------------------------------------------------------------
/tests/fixtures/challenges/test-challenge-full/files/test.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CTFd/ctfcli/c5abdd499bc9112c6832e047aa1c77b3052de05f/tests/fixtures/challenges/test-challenge-full/files/test.pdf


--------------------------------------------------------------------------------
/tests/fixtures/challenges/test-challenge-full/files/test.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CTFd/ctfcli/c5abdd499bc9112c6832e047aa1c77b3052de05f/tests/fixtures/challenges/test-challenge-full/files/test.png


--------------------------------------------------------------------------------
/tests/fixtures/challenges/test-challenge-invalid-dockerfile/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM nginx:mainline-alpine
2 | 
3 | WORKDIR /usr/share/nginx/html
4 | COPY src/ .
5 | 


--------------------------------------------------------------------------------
/tests/fixtures/challenges/test-challenge-invalid-dockerfile/challenge.yml:
--------------------------------------------------------------------------------
 1 | name: Test Challenge
 2 | category: New Test
 3 | description: New Test Description
 4 | attribution: New Test Attribution
 5 | value: 150
 6 | author: Test
 7 | type: standard
 8 | state: hidden
 9 | image: .
10 | 


--------------------------------------------------------------------------------
/tests/fixtures/challenges/test-challenge-invalid/challenge-empty.yml:
--------------------------------------------------------------------------------
1 | # empty challenge.yml


--------------------------------------------------------------------------------
/tests/fixtures/challenges/test-challenge-invalid/challenge-invalid.yml:
--------------------------------------------------------------------------------
1 | - this is
2 | - invalid
3 | - challenge.yml
4 | 


--------------------------------------------------------------------------------
/tests/fixtures/challenges/test-challenge-minimal/challenge.yml:
--------------------------------------------------------------------------------
1 | name: Test Challenge
2 | category: New Test
3 | description: New Test Description
4 | attribution: New Test Attribution
5 | value: 150
6 | author: Test
7 | type: standard
8 | state: hidden
9 | 


--------------------------------------------------------------------------------
/tests/utils/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/CTFd/ctfcli/c5abdd499bc9112c6832e047aa1c77b3052de05f/tests/utils/__init__.py


--------------------------------------------------------------------------------
/tests/utils/test_git.py:
--------------------------------------------------------------------------------
  1 | import subprocess
  2 | import unittest
  3 | from pathlib import Path
  4 | from unittest import mock
  5 | 
  6 | from ctfcli.utils.git import check_if_dir_is_inside_git_repo, get_git_repo_head_branch
  7 | 
  8 | 
  9 | class TestGetGitRepoHeadBranch(unittest.TestCase):
 10 |     def test_gets_head_branch_if_head_exists(self):
 11 |         # example output taken from ctfcli repo
 12 |         mock_output = b"""
 13 | ref: refs/heads/master  HEAD
 14 | 7b4a09af8414eb1f5f6da9a8422fb53b5e9cbc15        HEAD
 15 | 0370595efd5e9a211b05c55778fc4c0ae2fe70af        refs/heads/15-blank-challenge-template
 16 | 410d49503971cf0e16b29a1707b52d911945a59f        refs/heads/21-add-deploy-functionality
 17 | ca1f8be5c207e911a3110f1e0223a1f3db9aa269        refs/heads/30-writeup-folder
 18 | 2f12163e6c6a4d105bd5e4ac25167fac8c6f5168        refs/heads/32-add-flag-data-into-spec
 19 | 58270ef683a3f92c4beffc3528e1188e11ddb04f        refs/heads/46-install-state-simplified
 20 | 4d0e530edd08baebccafb71b6b613c49b67458bd        refs/heads/47-topics
 21 | 47cb2285604da69c9e5c9b6cd9b59a9b9c50b647        refs/heads/70-pages-support
 22 | c75b674c1b582852f18719b08b474515d138a14d        refs/heads/75-challenge-healthcheck
 23 | """
 24 |         with mock.patch("ctfcli.utils.git.subprocess.check_output", return_value=mock_output) as mock_check_output:
 25 |             expected_head_branch = "master"
 26 |             head_branch = get_git_repo_head_branch("https://github.com/CTFd/ctfcli")
 27 | 
 28 |             mock_check_output.assert_called_once_with(
 29 |                 [
 30 |                     "git",
 31 |                     "ls-remote",
 32 |                     "--symref",
 33 |                     "https://github.com/CTFd/ctfcli",
 34 |                     "HEAD",
 35 |                 ],
 36 |                 stderr=subprocess.DEVNULL,
 37 |             )
 38 |             self.assertEqual(expected_head_branch, head_branch)
 39 | 
 40 |     def test_returns_none_if_repository_not_found(self):
 41 |         with mock.patch("ctfcli.utils.git.subprocess.check_output") as mock_check_output:
 42 |             mock_check_output.side_effect = subprocess.CalledProcessError(128, [])
 43 |             head_branch = get_git_repo_head_branch("https://github.com/example/does-not-exist")
 44 | 
 45 |             mock_check_output.assert_called_once_with(
 46 |                 [
 47 |                     "git",
 48 |                     "ls-remote",
 49 |                     "--symref",
 50 |                     "https://github.com/example/does-not-exist",
 51 |                     "HEAD",
 52 |                 ],
 53 |                 stderr=subprocess.DEVNULL,
 54 |             )
 55 |             self.assertIsNone(head_branch)
 56 | 
 57 |     def test_returns_none_if_head_not_found(self):
 58 |         mock_output = b""
 59 | 
 60 |         with mock.patch("ctfcli.utils.git.subprocess.check_output", return_value=mock_output) as mock_check_output:
 61 |             head_branch = get_git_repo_head_branch("https://github.com/example/does-not-have-a-head-branch")
 62 | 
 63 |             mock_check_output.assert_called_once_with(
 64 |                 [
 65 |                     "git",
 66 |                     "ls-remote",
 67 |                     "--symref",
 68 |                     "https://github.com/example/does-not-have-a-head-branch",
 69 |                     "HEAD",
 70 |                 ],
 71 |                 stderr=subprocess.DEVNULL,
 72 |             )
 73 |             self.assertIsNone(head_branch)
 74 | 
 75 | 
 76 | class TestCheckIfDirIsInsideGitRepo(unittest.TestCase):
 77 |     def test_returns_true_if_inside_git_repo(self):
 78 |         mock_output = b"true\n"
 79 | 
 80 |         with mock.patch("ctfcli.utils.git.subprocess.check_output", return_value=mock_output) as mock_check_output:
 81 |             inside_git_repo = check_if_dir_is_inside_git_repo()
 82 | 
 83 |             mock_check_output.assert_called_once_with(
 84 |                 ["git", "rev-parse", "--is-inside-work-tree"],
 85 |                 cwd=None,
 86 |                 stderr=subprocess.DEVNULL,
 87 |             )
 88 |             self.assertTrue(inside_git_repo)
 89 | 
 90 |     def test_accepts_cwd(self):
 91 |         mock_output = b"true\n"
 92 | 
 93 |         with mock.patch("ctfcli.utils.git.subprocess.check_output", return_value=mock_output) as mock_check_output:
 94 |             cwd_path = Path("/tmp/test/ctfcli/test-challenges-dir")
 95 |             inside_git_repo = check_if_dir_is_inside_git_repo(cwd_path)
 96 | 
 97 |             mock_check_output.assert_called_once_with(
 98 |                 ["git", "rev-parse", "--is-inside-work-tree"],
 99 |                 cwd=cwd_path,
100 |                 stderr=subprocess.DEVNULL,
101 |             )
102 |             self.assertTrue(inside_git_repo)
103 | 
104 |         with mock.patch("ctfcli.utils.git.subprocess.check_output", return_value=mock_output) as mock_check_output:
105 |             cwd_path = "/tmp/test/ctfcli/test-challenges-dir"
106 |             inside_git_repo = check_if_dir_is_inside_git_repo(cwd_path)
107 | 
108 |             mock_check_output.assert_called_once_with(
109 |                 ["git", "rev-parse", "--is-inside-work-tree"],
110 |                 cwd=cwd_path,
111 |                 stderr=subprocess.DEVNULL,
112 |             )
113 |             self.assertTrue(inside_git_repo)
114 | 
115 |     def test_returns_false_if_outside_git_repo(self):
116 |         mock_output = b"fatal: not a git repository (or any of the parent directories): .git\n"
117 | 
118 |         with mock.patch("ctfcli.utils.git.subprocess.check_output", return_value=mock_output) as mock_check_output:
119 |             inside_git_repo = check_if_dir_is_inside_git_repo()
120 | 
121 |             mock_check_output.assert_called_once_with(
122 |                 ["git", "rev-parse", "--is-inside-work-tree"],
123 |                 cwd=None,
124 |                 stderr=subprocess.DEVNULL,
125 |             )
126 |             self.assertFalse(inside_git_repo)
127 | 
128 |     def test_returns_false_if_subprocess_raises(self):
129 |         with mock.patch("ctfcli.utils.git.subprocess.check_output") as mock_check_output:
130 |             mock_check_output.side_effect = subprocess.CalledProcessError(128, [])
131 |             inside_git_repo = check_if_dir_is_inside_git_repo()
132 | 
133 |             mock_check_output.assert_called_once_with(
134 |                 ["git", "rev-parse", "--is-inside-work-tree"],
135 |                 cwd=None,
136 |                 stderr=subprocess.DEVNULL,
137 |             )
138 |             self.assertFalse(inside_git_repo)
139 | 


--------------------------------------------------------------------------------
/tests/utils/test_tools.py:
--------------------------------------------------------------------------------
 1 | import unittest
 2 | from unittest import mock
 3 | 
 4 | from ctfcli.utils.tools import strings
 5 | 
 6 | 
 7 | class TestStrings(unittest.TestCase):
 8 |     @mock.patch("builtins.open", mock.mock_open(read_data="Hello\x02World\x88!"))
 9 |     def test_returns_printable(self):
10 |         result = strings("/tmp/test/ctfcli/doesnotmatter.bin")
11 |         self.assertEqual(["Hello", "World"], list(result))
12 | 
13 |     @mock.patch("builtins.open", mock.mock_open(read_data="Hello\x02Wor\x02ld\x88!"))
14 |     def test_does_not_catch_results_shorter_than_min_length(self):
15 |         result = strings("/tmp/test/ctfcli/doesnotmatter.bin", min_length=10)
16 |         self.assertEqual([], list(result))
17 | 
18 |         result = strings("/tmp/test/ctfcli/doesnotmatter.bin")
19 |         self.assertEqual(["Hello"], list(result))
20 | 
21 |         result = strings("/tmp/test/ctfcli/doesnotmatter.bin", min_length=2)
22 |         self.assertEqual(["Hello", "Wor", "ld"], list(result))
23 | 
24 |     @mock.patch("builtins.open", mock.mock_open(read_data="\x88\x02\x02\x88"))
25 |     def test_returns_empty_generator_if_no_strings_found(self):
26 |         result = strings("/tmp/test/ctfcli/doesnotmatter.bin")
27 |         self.assertEqual([], list(result))
28 | 


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