├── .github
    └── workflows
    │   └── lint.yml
├── .gitignore
├── .gitlab-ci.yml
├── CHANGELOG
├── LICENSE
├── MANIFEST.in
├── Makefile
├── README.md
├── ctfcli
    ├── __init__.py
    ├── __main__.py
    ├── cli
    │   ├── __init__.py
    │   ├── challenges.py
    │   ├── config.py
    │   └── plugins.py
    ├── spec
    │   └── challenge-example.yml
    ├── templates
    │   ├── binary
    │   │   └── default
    │   │   │   ├── cookiecutter.json
    │   │   │   └── {{cookiecutter.name}}
    │   │   │       ├── .dockerignore
    │   │   │       ├── Makefile
    │   │   │       ├── README.md
    │   │   │       ├── WRITEUP.md
    │   │   │       ├── challenge.yml
    │   │   │       └── src
    │   │   │           └── {{cookiecutter.name}}.c
    │   ├── crypto
    │   │   └── default
    │   │   │   ├── cookiecutter.json
    │   │   │   └── {{cookiecutter.name}}
    │   │   │       ├── Makefile
    │   │   │       ├── README.md
    │   │   │       ├── WRITEUP.md
    │   │   │       ├── challenge.yml
    │   │   │       └── src
    │   │   │           ├── encrypt.py
    │   │   │           └── flag.txt
    │   ├── programming
    │   │   └── default
    │   │   │   ├── cookiecutter.json
    │   │   │   └── {{cookiecutter.name}}
    │   │   │       ├── .dockerignore
    │   │   │       ├── Dockerfile
    │   │   │       ├── README.md
    │   │   │       ├── WRITEUP.md
    │   │   │       ├── challenge.yml
    │   │   │       ├── docker-compose.yml
    │   │   │       └── src
    │   │   │           ├── requirements.txt
    │   │   │           ├── serve.sh
    │   │   │           └── server.py
    │   └── web
    │   │   └── default
    │   │       ├── cookiecutter.json
    │   │       └── {{cookiecutter.name}}
    │   │           ├── .dockerignore
    │   │           ├── Dockerfile
    │   │           ├── README.md
    │   │           ├── WRITEUP.md
    │   │           ├── challenge.yml
    │   │           ├── docker-compose.yml
    │   │           └── src
    │   │               ├── app.py
    │   │               ├── requirements.txt
    │   │               ├── serve.sh
    │   │               └── templates
    │   │                   ├── base.html
    │   │                   └── index.html
    └── utils
    │   ├── __init__.py
    │   ├── api.py
    │   ├── challenge.py
    │   ├── config.py
    │   ├── plugins.py
    │   └── spec.py
├── development.txt
├── docs
    └── plugins.md
├── requirements.txt
└── setup.py


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


--------------------------------------------------------------------------------
/.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 | instance/
 66 | .webassets-cache
 67 | 
 68 | # Scrapy stuff:
 69 | .scrapy
 70 | 
 71 | # Sphinx documentation
 72 | docs/_build/
 73 | 
 74 | # PyBuilder
 75 | target/
 76 | 
 77 | # Jupyter Notebook
 78 | .ipynb_checkpoints
 79 | 
 80 | # IPython
 81 | profile_default/
 82 | ipython_config.py
 83 | 
 84 | # pyenv
 85 | .python-version
 86 | 
 87 | # pipenv
 88 | #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
 89 | #   However, in case of collaboration, if having platform-specific dependencies or dependencies
 90 | #   having no cross-platform support, pipenv may install dependencies that don't work, or not
 91 | #   install all needed dependencies.
 92 | #Pipfile.lock
 93 | 
 94 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow
 95 | __pypackages__/
 96 | 
 97 | # Celery stuff
 98 | celerybeat-schedule
 99 | celerybeat.pid
100 | 
101 | # SageMath parsed files
102 | *.sage.py
103 | 
104 | # Environments
105 | .env
106 | .venv
107 | env/
108 | venv/
109 | ENV/
110 | env.bak/
111 | venv.bak/
112 | 
113 | # Spyder project settings
114 | .spyderproject
115 | .spyproject
116 | 
117 | # Rope project settings
118 | .ropeproject
119 | 
120 | # mkdocs documentation
121 | /site
122 | 
123 | # mypy
124 | .mypy_cache/
125 | .dmypy.json
126 | dmypy.json
127 | 
128 | # Pyre type checker
129 | .pyre/
130 | 
131 | # Miscellaneous
132 | .DS_Store
133 | .vscode/
134 | 
135 | .ctf/
136 | 


--------------------------------------------------------------------------------
/.gitlab-ci.yml:
--------------------------------------------------------------------------------
 1 | image: python:3.7
 2 | 
 3 | before_script:
 4 |     - python -V
 5 |     - mkdir -p .pip
 6 |     - pip install --upgrade pip
 7 |     - pip install --cache-dir='.pip' -r development.txt
 8 | 
 9 | test:
10 |     script:
11 |     - make lint
12 | 


--------------------------------------------------------------------------------
/CHANGELOG:
--------------------------------------------------------------------------------
 1 | # Changelog
 2 | 
 3 | 
 4 | 0.0.4 / 2020-06-07
 5 | ==================
 6 | ### Added
 7 | - `ctfcli` will now load all challenges regardless of visibility when using an
 8 | admin token. Requires CTFd v2.5.0
 9 | 
10 | 
11 | 0.0.3 / 2020-04-09
12 | ==================
13 | ### Fixed
14 | - `ctf init` now saves the CTFd `access_token` properly
15 | 
16 | 
17 | 0.0.2 / 2020-04-02
18 | ==================
19 | ### Added
20 | - Initial release of ctfcli
21 | - `ctf init` commands
22 | - `ctf challenge` commands
23 | - `ctf config` commands
24 | - `ctf plugins` commands
25 | - README and basic example on plugins
26 | 
27 | ### Changed
28 | - Nothing
29 | 
30 | ### Removed
31 | - Removed initial stub release from source control
32 | 
33 | 
34 | 0.0.1 / 2020-01-01
35 | ==================
36 | 
37 | ### Added
38 | - Initial stub release of ctfcli
39 | 
40 | ### Changed
41 | - Nothing
42 | 
43 | ### Removed
44 | - Nothing
45 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/MANIFEST.in:
--------------------------------------------------------------------------------
1 | include LICENSE
2 | include README.md
3 | recursive-include ctfcli/templates *
4 | recursive-include ctfcli/utils *
5 | recursive-include ctfcli/spec *
6 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | lint:
 2 | 	flake8 --ignore=E402,E501,E712,W503,E203,I002 --exclude=ctfcli/templates **/*.py
 3 | 	black --check --exclude=ctfcli/templates .
 4 | 
 5 | format:
 6 | 	black --exclude=ctfcli/templates .
 7 | 
 8 | install:
 9 | 	python3 setup.py install
10 | 
11 | build:
12 | 	python3 setup.py sdist bdist_wheel
13 | 
14 | clean:
15 | 	rm -rf build/
16 | 	rm -rf dist/
17 | 	rm -rf ctfcli.egg-info/
18 | 
19 | publish-test:
20 | 	@echo "Publishing to TestPyPI"
21 | 	@echo "Are you sure? [y/N] " && read ans && [ $${ans:-N} == y ]
22 | 	python3 setup.py sdist bdist_wheel
23 | 	twine upload --repository test dist/*
24 | 
25 | publish-pypi:
26 | 	@echo "Publishing to PyPI"
27 | 	@echo "ARE YOU ABSOLUTELY SURE? [y/N] " && read ans && [ $${ans:-N} == y ]
28 | 	python3 setup.py sdist bdist_wheel
29 | 	twine upload --repository pypi dist/*


--------------------------------------------------------------------------------
/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 `pip install ctfcli`
 14 | 
 15 | ## 1. Create an Event
 16 | 
 17 | ctfcli turns the current folder into a CTF event git repo. It asks for the base url of the CTFd instance you're working with and an access token.
 18 | 
 19 | ```
 20 | ❯ ctf init
 21 | Please enter CTFd instance URL: https://demo.ctfd.io
 22 | Please enter CTFd Admin Access Token: d41d8cd98f00b204e9800998ecf8427e
 23 | Do you want to continue with https://demo.ctfd.io and d41d8cd98f00b204e9800998ecf8427e [y/N]: y
 24 | Initialized empty Git repository in /Users/user/Downloads/event/.git/
 25 | ```
 26 | 
 27 | This will create the `.ctf` folder with the `config` file that will specify the URL, access token, and keep a record of all the challenges dedicated for this event.
 28 | 
 29 | ## 2. Add challenges
 30 | 
 31 | Events are made up of challenges. Challenges can be made from a subdirectory or pulled from another repository. Remote challenges are pulled into the event repo and a reference is kept in the `.ctf/config` file.
 32 | 
 33 | ```
 34 | ❯ ctf challenge add [REPO | FOLDER]
 35 | ```
 36 | 
 37 | ```
 38 | ❯ ctf challenge add crypto/stuff
 39 | ```
 40 | 
 41 | ```
 42 | ❯ ctf challenge add https://github.com/challenge.git
 43 | challenge
 44 | Cloning into 'challenge'...
 45 | remote: Enumerating objects: 624, done.
 46 | remote: Counting objects: 100% (624/624), done.
 47 | remote: Compressing objects: 100% (540/540), done.
 48 | remote: Total 624 (delta 109), reused 335 (delta 45), pack-reused 0
 49 | Receiving objects: 100% (624/624), 6.49 MiB | 21.31 MiB/s, done.
 50 | Resolving deltas: 100% (109/109), done.
 51 | ```
 52 | 
 53 | ## 3. Install challenges
 54 | 
 55 | Installing a challenge will automatically create the challenge in your CTFd instance using the API.
 56 | 
 57 | ```
 58 | ❯ ctf challenge install [challenge.yml | DIRECTORY]
 59 | ```
 60 | 
 61 | ```
 62 | ❯ ctf challenge install buffer_overflow
 63 | Found buffer_overflow/challenge.yml
 64 | Loaded buffer_overflow
 65 | Installing buffer_overflow
 66 | Success!
 67 | ```
 68 | 
 69 | ## 4. Update challenges
 70 | 
 71 | Syncing a challenge will automatically update the challenge in your CTFd instance using the API. Any changes made in the `challenge.yml` file will be reflected in your instance.
 72 | 
 73 | ```
 74 | ❯ ctf challenge sync [challenge.yml | DIRECTORY]
 75 | ```
 76 | 
 77 | ```
 78 | ❯ ctf challenge sync buffer_overflow
 79 | Found buffer_overflow/challenge.yml
 80 | Loaded buffer_overflow
 81 | Syncing buffer_overflow
 82 | Success!
 83 | ```
 84 | 
 85 | # Challenge Templates
 86 | 
 87 | `ctfcli` contains pre-made challenge templates to make it faster to create CTF challenges with safe defaults.
 88 | 
 89 | ```
 90 | ctf challenge new
 91 |                 ├── binary
 92 |                 ├── crypto
 93 |                 ├── programming
 94 |                 └── web
 95 | ```
 96 | 
 97 | ```
 98 | ❯ ctf challenge new binary
 99 | /Users/user/.virtualenvs/ctfcli/lib/python3.7/site-packages/ctfcli-0.0.1-py3.7.egg/ctfcli/templates/binary/default
100 | name [Hello]: buffer_overflow
101 | 
102 | ❯ ls -1 buffer_overflow
103 | Makefile
104 | README.md
105 | WRITEUP.md
106 | challenge.yml
107 | dist/
108 | src/
109 | ```
110 | 
111 | **Contributions welcome on improving the challenge templates to make CTF challenges better for everyone!**
112 | 
113 | # Challenge Specification
114 | 
115 | `ctfcli` provides a [challenge specification](ctfcli/spec/challenge-example.yml) (`challenge.yml`) that outlines the major details of a challenge.
116 | 
117 | Every challenge generated by or processed by `ctfcli` should have a `challenge.yml` file.
118 | 
119 | 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`.
120 | 
121 | # Plugins
122 | 
123 | `ctfcli` plugins are essentially additions to to the command line interface via dynamic class modifications. See the [plugin documentation page](docs/plugins.md) for a simple example.
124 | 
125 | *`ctfcli` is an alpha project! The plugin interface is likely to change!*
126 | 


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


--------------------------------------------------------------------------------
/ctfcli/__main__.py:
--------------------------------------------------------------------------------
 1 | import configparser
 2 | import importlib
 3 | import os
 4 | import subprocess
 5 | import sys
 6 | from pathlib import Path
 7 | 
 8 | import click
 9 | 
10 | from ctfcli.cli.challenges import Challenge
11 | from ctfcli.cli.config import Config
12 | from ctfcli.cli.plugins import Plugins
13 | from ctfcli.utils.plugins import get_plugin_dir
14 | 
15 | import fire
16 | 
17 | 
18 | class CTFCLI(object):
19 |     def init(self):
20 |         ctf_url = click.prompt("Please enter CTFd instance URL")
21 |         ctf_token = click.prompt("Please enter CTFd Admin Access Token")
22 |         if (
23 |             click.confirm(f"Do you want to continue with {ctf_url} and {ctf_token}")
24 |             is False
25 |         ):
26 |             click.echo("Aborted!")
27 |             return
28 | 
29 |         if Path(".ctf").exists():
30 |             click.secho(".ctf/ folder already exists. Aborting!", fg="red")
31 |             return
32 | 
33 |         os.mkdir(".ctf")
34 | 
35 |         config = configparser.ConfigParser()
36 |         config["config"] = {"url": ctf_url, "access_token": ctf_token}
37 |         config["challenges"] = {}
38 | 
39 |         with open(".ctf/config", "a+") as f:
40 |             config.write(f)
41 | 
42 |         subprocess.call(["git", "init"])
43 | 
44 |     def config(self):
45 |         return COMMANDS.get("config")
46 | 
47 |     def challenge(self):
48 |         return COMMANDS.get("challenge")
49 | 
50 |     def plugins(self):
51 |         return COMMANDS.get("plugins")
52 | 
53 | 
54 | COMMANDS = {
55 |     "challenge": Challenge(),
56 |     "config": Config(),
57 |     "plugins": Plugins(),
58 |     "cli": CTFCLI(),
59 | }
60 | 
61 | 
62 | def main():
63 |     # Load plugins
64 |     plugin_dir = get_plugin_dir()
65 |     sys.path.insert(0, plugin_dir)
66 |     for plugin in sorted(os.listdir(plugin_dir)):
67 |         plugin_path = os.path.join(plugin_dir, plugin, "__init__.py")
68 |         print("Loading", plugin_path, "as", plugin)
69 |         loaded = importlib.import_module(plugin)
70 |         loaded.load(COMMANDS)
71 |     sys.path.remove(plugin_dir)
72 | 
73 |     # Load CLI
74 |     fire.Fire(CTFCLI)
75 | 
76 | 
77 | if __name__ == "__main__":
78 |     main()
79 | 


--------------------------------------------------------------------------------
/ctfcli/cli/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/JohnHammond/ctfcli/bb77391b737534de29f67bd37f5f26ef45890ec3/ctfcli/cli/__init__.py


--------------------------------------------------------------------------------
/ctfcli/cli/challenges.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import shutil
  3 | import subprocess
  4 | from cookiecutter.main import cookiecutter
  5 | from pathlib import Path
  6 | 
  7 | import click
  8 | import yaml
  9 | 
 10 | from ctfcli.utils.challenge import (
 11 |     create_challenge,
 12 |     lint_challenge,
 13 |     load_challenge,
 14 |     load_installed_challenges,
 15 |     sync_challenge,
 16 | )
 17 | from ctfcli.utils.config import (
 18 |     get_base_path,
 19 |     get_config_path,
 20 |     get_project_path,
 21 |     load_config,
 22 | )
 23 | from ctfcli.utils.spec import (
 24 |     CHALLENGE_SPEC_DOCS,
 25 |     blank_challenge_spec,
 26 | )
 27 | 
 28 | 
 29 | class Challenge(object):
 30 |     def new(self, type):
 31 |         path = Path(get_base_path())
 32 |         if os.sep not in type:
 33 |             type += os.sep + "default"
 34 |         path = path / "templates" / type
 35 |         cookiecutter(str(path))
 36 | 
 37 |     def add(self, repo):
 38 |         config = load_config()
 39 | 
 40 |         if repo.endswith(".git"):
 41 |             # Get relative path from project root to current directory
 42 |             challenge_path = Path(os.path.relpath(os.getcwd(), get_project_path()))
 43 | 
 44 |             # Get new directory that will exist after clone
 45 |             base_repo_path = Path(os.path.basename(repo).rsplit(".", maxsplit=1)[0])
 46 | 
 47 |             # Join targets
 48 |             challenge_path = challenge_path / base_repo_path
 49 |             print(challenge_path)
 50 | 
 51 |             config["challenges"][str(challenge_path)] = repo
 52 | 
 53 |             with open(get_config_path(), "w+") as f:
 54 |                 config.write(f)
 55 | 
 56 |             subprocess.call(["git", "clone", "--depth", "1", repo])
 57 |             shutil.rmtree(str(base_repo_path / ".git"))
 58 |         elif Path(repo).exists():
 59 |             config["challenges"][repo] = repo
 60 |             with open(get_config_path(), "w+") as f:
 61 |                 config.write(f)
 62 |         else:
 63 |             click.secho(
 64 |                 "Couldn't process that challenge path. Please check it for errors.",
 65 |                 fg="red",
 66 |             )
 67 | 
 68 |     def restore(self):
 69 |         config = load_config()
 70 |         challenges = dict(config["challenges"])
 71 |         for folder, url in challenges.items():
 72 |             if url.endswith(".git"):
 73 |                 click.echo(f"Cloning {url} to {folder}")
 74 |                 subprocess.call(["git", "clone", "--depth", "1", url, folder])
 75 |                 shutil.rmtree(str(Path(folder) / ".git"))
 76 |             else:
 77 |                 click.echo(f"Skipping {url} - {folder}")
 78 | 
 79 |     def install(self, challenge=None, force=False):
 80 |         if challenge is None:
 81 |             challenge = os.getcwd()
 82 | 
 83 |         path = Path(challenge)
 84 | 
 85 |         if path.name.endswith(".yml") is False:
 86 |             path = path / "challenge.yml"
 87 | 
 88 |         click.secho(f"Found {path}")
 89 |         challenge = load_challenge(path)
 90 |         click.secho(f'Loaded {challenge["name"]}', fg="yellow")
 91 | 
 92 |         installed_challenges = load_installed_challenges()
 93 |         for c in installed_challenges:
 94 |             if c["name"] == challenge["name"]:
 95 |                 click.secho(
 96 |                     "Already found existing challenge with same name. Perhaps you meant sync instead of install?",
 97 |                     fg="red",
 98 |                 )
 99 |                 if force is True:
100 |                     click.secho(
101 |                         "Ignoring existing challenge because of --force", fg="yellow"
102 |                     )
103 |                 else:
104 |                     return
105 | 
106 |         click.secho(f'Installing {challenge["name"]}', fg="yellow")
107 |         create_challenge(challenge=challenge, path=path)
108 |         click.secho(f"Success!", fg="green")
109 | 
110 |     def sync(self, challenge=None):
111 |         if challenge is None:
112 |             challenge = os.getcwd()
113 | 
114 |         path = Path(challenge)
115 | 
116 |         if path.name.endswith(".yml") is False:
117 |             path = path / "challenge.yml"
118 | 
119 |         click.secho(f"Found {path}")
120 |         challenge = load_challenge(path)
121 |         click.secho(f'Loaded {challenge["name"]}', fg="yellow")
122 | 
123 |         installed_challenges = load_installed_challenges()
124 |         for c in installed_challenges:
125 |             if c["name"] == challenge["name"]:
126 |                 break
127 |         else:
128 |             click.secho(
129 |                 "Couldn't find existing challenge. Perhaps you meant install instead of sync?",
130 |                 fg="red",
131 |             )
132 | 
133 |         click.secho(f'Syncing {challenge["name"]}', fg="yellow")
134 |         sync_challenge(challenge=challenge, path=path)
135 |         click.secho(f"Success!", fg="green")
136 | 
137 |     def finalize(self, challenge=None):
138 |         if challenge is None:
139 |             challenge = os.getcwd()
140 | 
141 |         path = Path(challenge)
142 |         spec = blank_challenge_spec()
143 |         for k in spec:
144 |             q = CHALLENGE_SPEC_DOCS.get(k)
145 |             fields = q._asdict()
146 | 
147 |             ask = False
148 |             required = fields.pop("required", False)
149 |             if required is False:
150 |                 try:
151 |                     ask = click.confirm(f"Would you like to add the {k} field?")
152 |                     if ask is False:
153 |                         continue
154 |                 except click.Abort:
155 |                     click.echo("\n")
156 |                     continue
157 | 
158 |             if ask is True:
159 |                 fields["text"] = "\t" + fields["text"]
160 | 
161 |             multiple = fields.pop("multiple", False)
162 |             if multiple:
163 |                 fields["text"] += " (Ctrl-C to continue)"
164 |                 spec[k] = []
165 |                 try:
166 |                     while True:
167 |                         r = click.prompt(**fields)
168 |                         spec[k].append(r)
169 |                 except click.Abort:
170 |                     click.echo("\n")
171 |             else:
172 |                 try:
173 |                     r = click.prompt(**fields)
174 |                     spec[k] = r
175 |                 except click.Abort:
176 |                     click.echo("\n")
177 | 
178 |         with open(path / "challenge.yml", "w+") as f:
179 |             yaml.dump(spec, stream=f, default_flow_style=False, sort_keys=False)
180 | 
181 |         print("challenge.yml written to", path / "challenge.yml")
182 | 
183 |     def lint(self, challenge=None):
184 |         if challenge is None:
185 |             challenge = os.getcwd()
186 | 
187 |         path = Path(challenge)
188 | 
189 |         if path.name.endswith(".yml") is False:
190 |             path = path / "challenge.yml"
191 | 
192 |         lint_challenge(path)
193 | 


--------------------------------------------------------------------------------
/ctfcli/cli/config.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import subprocess
 3 | 
 4 | import click
 5 | 
 6 | from pygments import highlight
 7 | from pygments.formatters import TerminalFormatter
 8 | from pygments.lexers import IniLexer, JsonLexer
 9 | from ctfcli.utils.config import get_config_path, preview_config
10 | 
11 | 
12 | class Config(object):
13 |     def edit(self):
14 |         editor = os.getenv("EDITOR", "vi")
15 |         command = editor, get_config_path()
16 |         subprocess.call(command)
17 | 
18 |     def path(self):
19 |         click.echo(get_config_path())
20 | 
21 |     def view(self, color=True, json=False):
22 |         config = get_config_path()
23 |         with open(config) as f:
24 |             if json is True:
25 |                 config = preview_config(as_string=True)
26 |                 if color:
27 |                     config = highlight(config, JsonLexer(), TerminalFormatter())
28 |             else:
29 |                 config = f.read()
30 |                 if color:
31 |                     config = highlight(config, IniLexer(), TerminalFormatter())
32 | 
33 |             print(config)
34 | 


--------------------------------------------------------------------------------
/ctfcli/cli/plugins.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import shutil
 3 | import subprocess
 4 | 
 5 | from ctfcli.utils.plugins import get_plugin_dir
 6 | 
 7 | 
 8 | class Plugins(object):
 9 |     def install(self, url):
10 |         local_dir = os.path.join(
11 |             get_plugin_dir(), os.path.basename(url).rsplit(".", maxsplit=1)[0]
12 |         )
13 |         subprocess.call(["git", "clone", url, local_dir])
14 |         subprocess.call(
15 |             ["pip", "install", "-r", os.path.join(local_dir, "requirements.txt")]
16 |         )
17 | 
18 |     def uninstall(self, plugin_name):
19 |         plugin_dir = os.path.join(get_plugin_dir(), plugin_name)
20 |         shutil.rmtree(plugin_dir)
21 | 
22 |     def list(self):
23 |         for plugin in sorted(os.listdir(get_plugin_dir())):
24 |             print(plugin)
25 | 
26 |     def dir(self):
27 |         print(get_plugin_dir())
28 | 


--------------------------------------------------------------------------------
/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 | value: 100
10 | type: standard
11 | 
12 | # Settings used for Dockerfile deployment
13 | # If not used, remove or set to null
14 | # If you have a Dockerfile set to .
15 | # 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)
16 | # Follow Docker best practices and assign a tag
17 | image: null
18 | 
19 | # Optional settings
20 | # Can be removed if unused
21 | attempts: 5
22 | 
23 | # Flags specify answers that your challenge use. You should generally provide
24 | # at least one.
25 | # Can be removed if unused
26 | # Accepts strings or dictionaries
27 | flags:
28 |     - flag{3xampl3}
29 |     - {
30 |         type: "static",
31 |         content: "flag{wat}",
32 |         data: "asdfasdfsdf",
33 |     }
34 | 
35 | # Tags are used to classify your challenge with topics. You should provide at
36 | # least one.
37 | # Can be removed if unused
38 | # Accepts strings
39 | tags:
40 |     - web
41 |     - sandbox
42 |     - js
43 | 
44 | # Provide paths to files from the same directory that this file is in
45 | # Accepts strings
46 | files:
47 |     - dist/source.py
48 | 
49 | # Hints are used to give players a way to buy or have suggestions. They are not
50 | # required but can be nice.
51 | # Can be removed if unused
52 | # Accepts dictionaries or strings
53 | hints:
54 |     - {
55 |         content: "This hint costs points",
56 |         cost: 10
57 |     }
58 |     - This hint is free
59 | 
60 | # Requirements are used to make a challenge require another challenge to be
61 | # solved before being available.
62 | # Can be removed if unused
63 | # Accepts challenge names as strings or challenge IDs as integers
64 | requirements:
65 |     - "Warmup"
66 |     - "Are you alive"
67 |     - 1
68 | 
69 | # The state of the challenge.
70 | # This is visible by default. It takes two values: hidden, visible.
71 | state: hidden
72 | 
73 | # Specifies what version of the challenge specification was used.
74 | # Subject to change until ctfcli v1.0.0
75 | version: "0.1"


--------------------------------------------------------------------------------
/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}}/WRITEUP.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/JohnHammond/ctfcli/bb77391b737534de29f67bd37f5f26ef45890ec3/ctfcli/templates/binary/default/{{cookiecutter.name}}/WRITEUP.md


--------------------------------------------------------------------------------
/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/crypto/default/cookiecutter.json:
--------------------------------------------------------------------------------
1 | {
2 |     "name": "Hello"
3 | }


--------------------------------------------------------------------------------
/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}}/WRITEUP.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/JohnHammond/ctfcli/bb77391b737534de29f67bd37f5f26ef45890ec3/ctfcli/templates/crypto/default/{{cookiecutter.name}}/WRITEUP.md


--------------------------------------------------------------------------------
/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/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}}/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM python:3.7-alpine
 2 | 
 3 | RUN apk update && \
 4 |     apk add \
 5 |         socat
 6 | RUN mkdir "/opt/{{cookiecutter.name}}"
 7 | COPY ./src/* "/opt/{{cookiecutter.name}}/"
 8 | RUN pip install -r "/opt/{{cookiecutter.name}}/requirements.txt"
 9 | 
10 | EXPOSE {{cookiecutter.port}}
11 | WORKDIR "/opt/{{cookiecutter.name}}/"
12 | CMD ./serve.sh
13 | 


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


--------------------------------------------------------------------------------
/ctfcli/templates/programming/default/{{cookiecutter.name}}/WRITEUP.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/JohnHammond/ctfcli/bb77391b737534de29f67bd37f5f26ef45890ec3/ctfcli/templates/programming/default/{{cookiecutter.name}}/WRITEUP.md


--------------------------------------------------------------------------------
/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 |         - '8000:8000'
7 | 


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


--------------------------------------------------------------------------------
/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/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-alpine
 2 | RUN apk update && \
 3 |     apk add \
 4 |         python \
 5 |         python-dev \
 6 |         linux-headers \
 7 |         libffi-dev \
 8 |         gcc \
 9 |         make \
10 |         musl-dev \
11 |         py-pip \
12 |         mysql-client \
13 |         git \
14 |         openssl-dev
15 | RUN adduser -D -u 1001 -s /bin/bash app
16 | 
17 | WORKDIR /opt/app
18 | RUN mkdir -p /opt/app
19 | 
20 | COPY src/ /opt/app/
21 | 
22 | RUN pip install -r requirements.txt
23 | 
24 | USER 1001
25 | EXPOSE 8000
26 | ENTRYPOINT ["/opt/app/serve.sh"]


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


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/{{cookiecutter.name}}/WRITEUP.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/JohnHammond/ctfcli/bb77391b737534de29f67bd37f5f26ef45890ec3/ctfcli/templates/web/default/{{cookiecutter.name}}/WRITEUP.md


--------------------------------------------------------------------------------
/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 | from flask import Flask, render_template
 3 | from flask_bootstrap import Bootstrap
 4 | 
 5 | app = Flask(__name__)
 6 | app.config["BOOTSTRAP_SERVE_LOCAL"] = True
 7 | bootstrap = Bootstrap(app)
 8 | 
 9 | 
10 | @app.route("/")
11 | def index():
12 |     return render_template("index.html")
13 | 
14 | 
15 | if __name__ == "__main__":
16 |     app.run(debug=True, threaded=True)
17 | 


--------------------------------------------------------------------------------
/ctfcli/templates/web/default/{{cookiecutter.name}}/src/requirements.txt:
--------------------------------------------------------------------------------
1 | gunicorn==19.10.0
2 | Flask==1.1.1
3 | Bootstrap-Flask==1.2.0
4 | 


--------------------------------------------------------------------------------
/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/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 |     {% block styles %}
14 |     {% endblock %}
15 | </head>
16 | {% endraw %}
17 | 
18 | <body>
19 |     <nav class="navbar navbar-expand-md navbar-dark fixed-top bg-dark">
20 |         <a class="navbar-brand" href="#">{{cookiecutter.name}}</a>
21 | 
22 |         <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarCollapse">
23 |             <span class="navbar-toggler-icon"></span>
24 |         </button>
25 | 
26 |         <div class="collapse navbar-collapse" id="navbarCollapse">
27 |             <ul class="navbar-nav mr-auto">
28 |                 <li class="nav-item active">
29 |                     <a class="nav-link" href="#">Home <span class="sr-only">(current)</span></a>
30 |                 </li>
31 |                 <li class="nav-item">
32 |                     <a class="nav-link" href="#">Link</a>
33 |                 </li>
34 |             </ul>
35 |         </div>
36 |     </nav>
37 | 
38 |     {% raw %}
39 |     <main role="main" class="container">
40 |         {% block content %}{% endblock %}
41 |     </main>
42 |     {% endraw %}
43 | 
44 | 
45 |     {% raw %}
46 |     {% block bootstrap_js %}
47 |     {{ bootstrap.load_js() }}
48 |     {% endblock %}
49 | 
50 |     {% block scripts %}
51 |     {% endblock %}
52 |     {% endraw %}
53 | </body>
54 | 
55 | </html>
56 | 


--------------------------------------------------------------------------------
/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/utils/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/JohnHammond/ctfcli/bb77391b737534de29f67bd37f5f26ef45890ec3/ctfcli/utils/__init__.py


--------------------------------------------------------------------------------
/ctfcli/utils/api.py:
--------------------------------------------------------------------------------
 1 | from urllib.parse import urljoin
 2 | 
 3 | from requests import Session
 4 | 
 5 | 
 6 | class APISession(Session):
 7 |     def __init__(self, prefix_url=None, *args, **kwargs):
 8 |         super(APISession, self).__init__(*args, **kwargs)
 9 |         self.prefix_url = prefix_url
10 | 
11 |     def request(self, method, url, *args, **kwargs):
12 |         url = urljoin(self.prefix_url, url)
13 |         return super(APISession, self).request(method, url, *args, **kwargs)
14 | 


--------------------------------------------------------------------------------
/ctfcli/utils/challenge.py:
--------------------------------------------------------------------------------
  1 | import yaml
  2 | 
  3 | import click
  4 | import os
  5 | 
  6 | from .config import generate_session
  7 | 
  8 | 
  9 | def load_challenge(path):
 10 |     try:
 11 |         with open(path) as f:
 12 |             return yaml.safe_load(f.read())
 13 |     except FileNotFoundError:
 14 |         click.secho(f"No challenge.yml was found in {path}", fg="red")
 15 |         return
 16 | 
 17 | 
 18 | def load_installed_challenges():
 19 |     s = generate_session()
 20 |     return s.get("/api/v1/challenges?view=admin", json=True).json()["data"]
 21 | 
 22 | 
 23 | def sync_challenge(challenge, path = None):
 24 |     data = {
 25 |         "name": challenge["name"],
 26 |         "category": challenge["category"],
 27 |         "description": challenge["description"],
 28 |         "type": challenge.get("type", "standard"),
 29 |         "value": int(challenge["value"]),
 30 |     }
 31 |     if challenge.get("attempts"):
 32 |         data["max_attempts"] = challenge.get("attempts")
 33 | 
 34 |     data["state"] = "hidden"
 35 | 
 36 |     installed_challenges = load_installed_challenges()
 37 |     for c in installed_challenges:
 38 |         if c["name"] == challenge["name"]:
 39 |             challenge_id = c["id"]
 40 |             break
 41 |     else:
 42 |         return
 43 | 
 44 |     s = generate_session()
 45 | 
 46 |     original_challenge = s.get(f"/api/v1/challenges/{challenge_id}", json=data).json()[
 47 |         "data"
 48 |     ]
 49 | 
 50 |     r = s.patch(f"/api/v1/challenges/{challenge_id}", json=data)
 51 |     r.raise_for_status()
 52 | 
 53 |     # Delete existing flags
 54 |     current_flags = s.get(f"/api/v1/flags", json=data).json()["data"]
 55 |     for flag in current_flags:
 56 |         if flag["challenge_id"] == challenge_id:
 57 |             flag_id = flag["id"]
 58 |             r = s.delete(f"/api/v1/flags/{flag_id}", json=True)
 59 |             r.raise_for_status()
 60 | 
 61 |     # Create new flags
 62 |     if challenge.get("flags"):
 63 |         for flag in challenge["flags"]:
 64 |             if type(flag) == str:
 65 |                 data = {"content": flag, "type": "static", "challenge": challenge_id}
 66 |                 r = s.post(f"/api/v1/flags", json=data)
 67 |                 r.raise_for_status()
 68 | 
 69 |     # Delete existing tags
 70 |     current_tags = s.get(f"/api/v1/tags", json=data).json()["data"]
 71 |     for tag in current_tags:
 72 |         if tag["challenge_id"] == challenge_id:
 73 |             tag_id = tag["id"]
 74 |             r = s.delete(f"/api/v1/tags/{tag_id}", json=True)
 75 |             r.raise_for_status()
 76 | 
 77 |     # Update tags
 78 |     if challenge.get("tags"):
 79 |         for tag in challenge["tags"]:
 80 |             r = s.post(f"/api/v1/tags", json={"challenge": challenge_id, "value": tag})
 81 |             r.raise_for_status()
 82 | 
 83 |     # Delete existing files
 84 |     all_current_files = s.get(f"/api/v1/files?type=challenge", json=data).json()["data"]
 85 |     for f in all_current_files:
 86 |         for used_file in original_challenge["files"]:
 87 |             if f["location"] in used_file:
 88 |                 file_id = f["id"]
 89 |                 r = s.delete(f"/api/v1/files/{file_id}", json=True)
 90 |                 r.raise_for_status()
 91 | 
 92 |     # Upload files
 93 |     if challenge.get("files"):
 94 |         files = []
 95 |         for f in challenge["files"]:
 96 | 
 97 |             if not os.path.exists(f):
 98 |                 if path is not None:
 99 |                     rel_path = os.path.join(os.path.dirname(path), f)
100 |                     if not os.path.exists(rel_path):
101 |                         click.secho(f"File {f} was not found", fg="red")
102 |                         return
103 |                     f = rel_path
104 | 
105 |             files.append(("file", open(f, "rb")))
106 | 
107 |         data = {"challenge": challenge_id, "type": "challenge"}
108 |         # Specifically use data= here instead of json= to send multipart/form-data
109 |         r = s.post(f"/api/v1/files", files=files, data=data)
110 |         r.raise_for_status()
111 | 
112 |     # Delete existing hints
113 |     current_hints = s.get(f"/api/v1/hints", json=data).json()["data"]
114 |     for hint in current_hints:
115 |         if hint["challenge_id"] == challenge_id:
116 |             hint_id = hint["id"]
117 |             r = s.delete(f"/api/v1/hints/{hint_id}", json=True)
118 |             r.raise_for_status()
119 | 
120 |     # Create hints
121 |     if challenge.get("hints"):
122 |         for hint in challenge["hints"]:
123 |             if type(hint) == str:
124 |                 data = {"content": hint, "cost": 0, "challenge": challenge_id}
125 |             else:
126 |                 data = {
127 |                     "content": hint["content"],
128 |                     "cost": hint["cost"],
129 |                     "challenge": challenge_id,
130 |                 }
131 | 
132 |             r = s.post(f"/api/v1/hints", json=data)
133 |             r.raise_for_status()
134 | 
135 |     # Update requirements
136 |     if challenge.get("requirements"):
137 |         installed_challenges = load_installed_challenges()
138 |         required_challenges = []
139 |         for r in challenge["requirements"]:
140 |             if type(r) == str:
141 |                 for c in installed_challenges:
142 |                     if c["name"] == r:
143 |                         required_challenges.append(c["id"])
144 |             elif type(r) == int:
145 |                 required_challenges.append(r)
146 | 
147 |         required_challenges = list(set(required_challenges))
148 |         data = {"requirements": {"prerequisites": required_challenges}}
149 |         r = s.patch(f"/api/v1/challenges/{challenge_id}", json=data)
150 |         r.raise_for_status()
151 | 
152 |     # Unhide challenge depending upon the value of "state" in spec
153 |     data = {"state": "hidden"}
154 |     if challenge.get("state"):
155 |         if challenge["state"] in ["hidden", "visible"]:
156 |             data["state"] = challenge["state"]
157 |     else:
158 |         data["state"] = "visible"
159 | 
160 |     r = s.patch(f"/api/v1/challenges/{challenge_id}", json=data)
161 |     r.raise_for_status()
162 | 
163 | 
164 | def create_challenge(challenge, path=None):
165 |     data = {
166 |         "name": challenge["name"],
167 |         "category": challenge["category"],
168 |         "description": challenge["description"],
169 |         "type": challenge.get("type", "standard"),
170 |         "value": int(challenge["value"]),
171 |     }
172 |     if challenge.get("attempts"):
173 |         data["max_attempts"] = challenge.get("attempts")
174 | 
175 |     s = generate_session()
176 | 
177 |     r = s.post("/api/v1/challenges", json=data)
178 |     r.raise_for_status()
179 | 
180 |     challenge_data = r.json()
181 |     challenge_id = challenge_data["data"]["id"]
182 | 
183 |     # Create flags
184 |     if challenge.get("flags"):
185 |         for flag in challenge["flags"]:
186 |             if type(flag) == str:
187 |                 data = {"content": flag, "type": "static", "challenge": challenge_id}
188 |                 r = s.post(f"/api/v1/flags", json=data)
189 |                 r.raise_for_status()
190 | 
191 |     # Create tags
192 |     if challenge.get("tags"):
193 |         for tag in challenge["tags"]:
194 |             r = s.post(f"/api/v1/tags", json={"challenge": challenge_id, "value": tag})
195 |             r.raise_for_status()
196 | 
197 |     # Upload files
198 |     if challenge.get("files"):
199 |         files = []
200 |         for f in challenge["files"]:
201 | 
202 |             if not os.path.exists(f):
203 |                 if path is not None:
204 |                     rel_path = os.path.join(os.path.dirname(path), f)
205 |                     if not os.path.exists(rel_path):
206 |                         click.secho(f"File {f} was not found", fg="red")
207 |                         return
208 |                     f = rel_path
209 | 
210 |             files.append(("file", open(f, "rb")))
211 | 
212 |         data = {"challenge": challenge_id, "type": "challenge"}
213 |         # Specifically use data= here instead of json= to send multipart/form-data
214 |         r = s.post(f"/api/v1/files", files=files, data=data)
215 |         r.raise_for_status()
216 | 
217 |     # Add hints
218 |     if challenge.get("hints"):
219 |         for hint in challenge["hints"]:
220 |             if type(hint) == str:
221 |                 data = {"content": hint, "cost": 0, "challenge": challenge_id}
222 |             else:
223 |                 data = {
224 |                     "content": hint["content"],
225 |                     "cost": hint["cost"],
226 |                     "challenge": challenge_id,
227 |                 }
228 | 
229 |             r = s.post(f"/api/v1/hints", json=data)
230 |             r.raise_for_status()
231 | 
232 |     # Add requirements
233 |     if challenge.get("requirements"):
234 |         installed_challenges = load_installed_challenges()
235 |         required_challenges = []
236 |         for r in challenge["requirements"]:
237 |             if type(r) == str:
238 |                 for c in installed_challenges:
239 |                     if c["name"] == r:
240 |                         required_challenges.append(c["id"])
241 |             elif type(r) == int:
242 |                 required_challenges.append(r)
243 | 
244 |         required_challenges = list(set(required_challenges))
245 |         data = {"requirements": {"prerequisites": required_challenges}}
246 |         r = s.patch(f"/api/v1/challenges/{challenge_id}", json=data)
247 |         r.raise_for_status()
248 | 
249 |     # Set challenge state
250 |     if challenge.get("state"):
251 |         data = {"state": "hidden"}
252 |         if challenge["state"] in ["hidden", "visible"]:
253 |             data["state"] = challenge["state"]
254 | 
255 |         r = s.patch(f"/api/v1/challenges/{challenge_id}", json=data)
256 |         r.raise_for_status()
257 | 
258 | 
259 | def lint_challenge(path):
260 |     try:
261 |         challenge = load_challenge(path)
262 |     except yaml.YAMLError as e:
263 |         click.secho(f"Error parsing challenge.yml: {e}", fg="red")
264 |         exit(1)
265 | 
266 |     required_fields = ["name", "author", "category", "description", "value"]
267 |     errors = []
268 |     for field in required_fields:
269 |         if challenge.get(field) is None:
270 |             errors.append(field)
271 | 
272 |     if len(errors) > 0:
273 |         print("Missing fields: ", ", ".join(errors))
274 |         exit(1)
275 | 
276 |     exit(0)
277 | 


--------------------------------------------------------------------------------
/ctfcli/utils/config.py:
--------------------------------------------------------------------------------
 1 | import configparser
 2 | import json
 3 | import os
 4 | 
 5 | from .api import APISession
 6 | 
 7 | from ctfcli import __file__ as base_path
 8 | 
 9 | 
10 | def get_base_path():
11 |     return os.path.dirname(base_path)
12 | 
13 | 
14 | def get_config_path():
15 |     pwd = os.getcwd()
16 |     while pwd:
17 |         config = os.path.join(pwd, ".ctf/config")
18 |         if os.path.isfile(config):
19 |             return config
20 |         new_pwd = os.path.dirname(pwd)
21 |         pwd = None if new_pwd == pwd else new_pwd
22 |     return None
23 | 
24 | 
25 | def get_project_path():
26 |     pwd = os.getcwd()
27 |     while pwd:
28 |         config = os.path.join(pwd, ".ctf/config")
29 |         if os.path.isfile(config):
30 |             return pwd
31 |         new_pwd = os.path.dirname(pwd)
32 |         pwd = None if new_pwd == pwd else new_pwd
33 |     return None
34 | 
35 | 
36 | def load_config():
37 |     path = get_config_path()
38 |     parser = configparser.ConfigParser()
39 | 
40 |     # Preserve case in configparser
41 |     parser.optionxform = str
42 | 
43 |     parser.read(path)
44 |     return parser
45 | 
46 | 
47 | def preview_config(as_string=False):
48 |     config = load_config()
49 | 
50 |     d = {}
51 |     for section in config.sections():
52 |         d[section] = {}
53 |         for k, v in config.items(section):
54 |             d[section][k] = v
55 | 
56 |     preview = json.dumps(d, sort_keys=True, indent=4)
57 | 
58 |     if as_string is True:
59 |         return preview
60 |     else:
61 |         print(preview)
62 | 
63 | 
64 | def generate_session():
65 |     config = load_config()
66 |     url = config["config"]["url"]
67 |     url = url.strip("/")
68 |     access_token = config["config"]["access_token"]
69 |     s = APISession(url)
70 |     s.headers.update({"Authorization": f"Token {access_token}"})
71 |     return s
72 | 


--------------------------------------------------------------------------------
/ctfcli/utils/plugins.py:
--------------------------------------------------------------------------------
 1 | import appdirs
 2 | import os
 3 | 
 4 | from ctfcli import __name__ as pkg_name
 5 | 
 6 | 
 7 | def get_plugin_dir():
 8 |     plugins_path = os.path.join(get_data_dir(), "plugins")
 9 |     if not os.path.exists(plugins_path):
10 |         os.makedirs(plugins_path)
11 |     return os.path.join(plugins_path)
12 | 
13 | 
14 | def get_data_dir():
15 |     return appdirs.user_data_dir(appname=pkg_name)
16 | 


--------------------------------------------------------------------------------
/ctfcli/utils/spec.py:
--------------------------------------------------------------------------------
  1 | import yaml
  2 | 
  3 | from collections import namedtuple
  4 | from pathlib import Path
  5 | import getpass
  6 | 
  7 | 
  8 | Prompt = namedtuple("Prompt", ["text", "type", "default", "required", "multiple"])
  9 | 
 10 | 
 11 | CHALLENGE_SPEC_DOCS = {
 12 |     "name": Prompt(
 13 |         text="Challenge name or identifier",
 14 |         type=None,
 15 |         default=None,
 16 |         required=True,
 17 |         multiple=False,
 18 |     ),
 19 |     "author": Prompt(
 20 |         text="Your name or handle",
 21 |         type=None,
 22 |         default=getpass.getuser(),
 23 |         required=True,
 24 |         multiple=False,
 25 |     ),
 26 |     "category": Prompt(
 27 |         text="Challenge category",
 28 |         type=None,
 29 |         default=None,
 30 |         required=True,
 31 |         multiple=False,
 32 |     ),
 33 |     "description": Prompt(
 34 |         text="Challenge description shown to the user",
 35 |         type=None,
 36 |         default=None,
 37 |         required=True,
 38 |         multiple=False,
 39 |     ),
 40 |     "value": Prompt(
 41 |         text="How many points your challenge should be worth",
 42 |         type=int,
 43 |         default=None,
 44 |         required=True,
 45 |         multiple=False,
 46 |     ),
 47 |     "version": Prompt(
 48 |         text="What version of the challenge specification was used",
 49 |         type=None,
 50 |         default="0.1",
 51 |         required=False,
 52 |         multiple=False,
 53 |     ),
 54 |     "image": Prompt(
 55 |         text="Docker image used to deploy challenge",
 56 |         type=None,
 57 |         default=None,
 58 |         required=False,
 59 |         multiple=False,
 60 |     ),
 61 |     "type": Prompt(
 62 |         text="Type of challenge",
 63 |         type=None,
 64 |         default="standard",
 65 |         required=True,
 66 |         multiple=False,
 67 |     ),
 68 |     "attempts": Prompt(
 69 |         text="How many attempts should the player have",
 70 |         type=int,
 71 |         default=None,
 72 |         required=False,
 73 |         multiple=False,
 74 |     ),
 75 |     "flags": Prompt(
 76 |         text="Flags that mark the challenge as solved",
 77 |         type=None,
 78 |         default=None,
 79 |         required=False,
 80 |         multiple=True,
 81 |     ),
 82 |     "tags": Prompt(
 83 |         text="Tag that denotes a challenge topic",
 84 |         type=None,
 85 |         default=None,
 86 |         required=False,
 87 |         multiple=True,
 88 |     ),
 89 |     "files": Prompt(
 90 |         text="Files to be shared with the user",
 91 |         type=None,
 92 |         default=None,
 93 |         required=False,
 94 |         multiple=True,
 95 |     ),
 96 |     "hints": Prompt(
 97 |         text="Hints to be shared with the user",
 98 |         type=None,
 99 |         default=None,
100 |         required=False,
101 |         multiple=True,
102 |     ),
103 |     "requirements": Prompt(
104 |         text="Challenge dependencies that must be solved before this one can be attempted",
105 |         type=None,
106 |         default=None,
107 |         required=False,
108 |         multiple=True,
109 |     ),
110 | }
111 | 
112 | 
113 | def blank_challenge_spec():
114 |     pwd = Path(__file__)
115 |     spec = pwd.parent.parent / "spec" / "challenge-example.yml"
116 |     with open(spec) as f:
117 |         blank = yaml.safe_load(f)
118 | 
119 |     for k in blank:
120 |         if k != "version":
121 |             blank[k] = None
122 | 
123 |     return blank
124 | 


--------------------------------------------------------------------------------
/development.txt:
--------------------------------------------------------------------------------
1 | -r requirements.txt
2 | twine==3.1.1
3 | setuptools==46.1.3
4 | wheel==0.34.2
5 | black==19.10b0
6 | flake8==3.7.9
7 | flake8-bugbear==20.1.2
8 | flake8-comprehensions==3.1.4
9 | flake8-isort==2.8.0


--------------------------------------------------------------------------------
/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 | ```


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
 1 | cookiecutter==1.6.0
 2 | click==7.0
 3 | fire==0.2.1
 4 | pyyaml==5.4
 5 | Pygments==2.7.4
 6 | requests==2.22.0
 7 | colorama==0.4.3
 8 | appdirs==1.4.3
 9 | urllib3>=1.26.5 # not directly required, pinned by Snyk to avoid a vulnerability
10 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | import re
 3 | 
 4 | try:
 5 |     from setuptools import setup, find_packages
 6 | except ImportError:
 7 |     from distutils.core import setup, find_packages
 8 | 
 9 | import os
10 | 
11 | with open("ctfcli/__init__.py") as f:
12 |     version = re.search(r'__version__ = "(.*?)"', f.read()).group(1)
13 | 
14 | 
15 | def read(fname):
16 |     try:
17 |         with open(os.path.join(os.path.dirname(__file__), fname), "r") as fp:
18 |             return fp.read().strip()
19 |     except IOError:
20 |         return ""
21 | 
22 | 
23 | setup(
24 |     name="ctfcli",
25 |     version=version,
26 |     author="Kevin Chung",
27 |     author_email="kchung@ctfd.io",
28 |     license="Apache 2.0",
29 |     description="Tool for creating and running Capture The Flag competitions",
30 |     long_description=read("README.md"),
31 |     long_description_content_type="text/markdown",
32 |     keywords=["ctf"],
33 |     classifiers=[],
34 |     install_requires=[
35 |         "cookiecutter==1.6.0",
36 |         "click==7.0",
37 |         "fire==0.2.1",
38 |         "pyyaml==5.2",
39 |         "Pygments==2.5.2",
40 |         "requests==2.22.0",
41 |         "colorama==0.4.3",
42 |         "appdirs==1.4.3",
43 |     ],
44 |     packages=find_packages(),
45 |     include_package_data=True,
46 |     entry_points={"console_scripts": ["ctf = ctfcli.__main__:main"]},
47 | )
48 | 


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