5 | Container challenges dynamically spin up a Docker container for each team to run the challenge on.
6 |
7 | {% endblock %}
8 |
9 | {% block value %}
10 |
11 |
17 |
19 |
20 |
21 |
26 |
27 |
28 |
29 |
30 |
31 |
36 |
37 |
38 |
39 |
40 |
45 |
46 |
47 |
48 |
49 |
55 |
59 |
60 |
61 |
62 |
68 |
75 |
76 |
77 |
78 |
84 |
85 |
86 |
87 |
88 |
94 |
95 |
96 |
97 |
98 |
105 |
106 |
107 | {% endblock %}
108 |
109 | {% block type %}
110 |
111 | {% endblock %}
--------------------------------------------------------------------------------
/assets/create.js:
--------------------------------------------------------------------------------
1 | CTFd.plugin.run((_CTFd) => {
2 | const $ = _CTFd.lib.$;
3 | const md = _CTFd.lib.markdown();
4 | });
5 |
6 | var containerImage = document.getElementById("container-image");
7 | var containerImageDefault = document.getElementById("container-image-default");
8 | var path = "/containers/api/images";
9 |
10 | fetch(path, {
11 | method: "GET",
12 | headers: {
13 | "Accept": "application/json",
14 | "CSRF-Token": init.csrfNonce
15 | }
16 | })
17 | .then(response => {
18 | if (!response.ok) {
19 | // Handle error response
20 | return Promise.reject("Error fetching data");
21 | }
22 | return response.json();
23 | })
24 | .then(data => {
25 | if (data.error != undefined) {
26 | // Error
27 | containerImageDefault.innerHTML = data.error;
28 | } else {
29 | // Success
30 | for (var i = 0; i < data.images.length; i++) {
31 | var opt = document.createElement("option");
32 | opt.value = data.images[i];
33 | opt.innerHTML = data.images[i];
34 | containerImage.appendChild(opt);
35 | }
36 | containerImageDefault.innerHTML = "Choose an image...";
37 | containerImage.removeAttribute("disabled");
38 | }
39 | console.log(data);
40 | })
41 | .catch(error => {
42 | // Handle fetch error
43 | console.error(error);
44 | });
45 |
--------------------------------------------------------------------------------
/assets/update.html:
--------------------------------------------------------------------------------
1 | {% extends "admin/challenges/update.html" %}
2 |
3 | {% block connection_info %}
4 |
5 |
11 |
13 |
14 | {% endblock %}
15 |
16 | {% block value %}
17 |
18 |
19 |
24 |
25 |
26 |
27 |
28 |
33 |
34 |
35 |
36 |
37 |
42 |
43 |
44 |
45 |
46 |
51 |
52 |
53 |
54 |
55 |
58 |
64 |
68 |
69 |
70 |
71 |
77 |
84 |
85 |
86 | {% if challenge.ctype == "ssh" %}
87 |
88 |
94 |
95 |
96 |
97 |
98 |
104 |
105 |
106 | {% endif %}
107 |
108 |
109 |
115 |
116 |
117 |
118 |
119 |
125 |
126 |
127 |
128 |
129 |
136 |
137 |
138 | {% endblock %}
--------------------------------------------------------------------------------
/assets/update.js:
--------------------------------------------------------------------------------
1 | var containerImage = document.getElementById("container-image");
2 | var containerImageDefault = document.getElementById("container-image-default");
3 | var path = "/containers/api/images";
4 |
5 | fetch(path, {
6 | method: "GET",
7 | headers: {
8 | "Accept": "application/json",
9 | "CSRF-Token": init.csrfNonce
10 | }
11 | })
12 | .then(response => response.json())
13 | .then(data => {
14 | if (data.error !== undefined) {
15 | // Error
16 | containerImageDefault.innerHTML = data.error;
17 | } else {
18 | // Success
19 | for (var i = 0; i < data.images.length; i++) {
20 | var opt = document.createElement("option");
21 | opt.value = data.images[i];
22 | opt.innerHTML = data.images[i];
23 | containerImage.appendChild(opt);
24 | }
25 | containerImageDefault.innerHTML = "Choose an image...";
26 | containerImage.removeAttribute("disabled");
27 | containerImage.value = container_image_selected;
28 | }
29 | })
30 | .catch(error => {
31 | console.error("Fetch error:", error);
32 | });
33 |
34 | var currentURL = window.location.href;
35 | var match = currentURL.match(/\/challenges\/(\d+)/);
36 |
37 | if (match && match[1]) {
38 | var challenge_id = parseInt(match[1]);
39 |
40 | var connectType = document.getElementById("connect-type");
41 | var connectTypeDefault = document.getElementById("connect-type-default");
42 |
43 | var connectTypeEndpoint = "/containers/api/get_connect_type/" + challenge_id;
44 |
45 | fetch(connectTypeEndpoint, {
46 | method: "GET",
47 | headers: {
48 | "Accept": "application/json",
49 | "CSRF-Token": init.csrfNonce
50 | }
51 | })
52 | .then(response => response.json())
53 | .then(connectTypeData => {
54 | if (connectTypeData.error !== undefined) {
55 | console.error("Error:", connectTypeData.error);
56 | } else {
57 | var connectTypeValue = connectTypeData.connect;
58 | connectTypeDefault.innerHTML = "Choose...";
59 | connectType.removeAttribute("disabled");
60 | connectType.value = connectTypeValue;
61 | }
62 | })
63 | .catch(error => {
64 | console.error("Fetch error:", error);
65 | });
66 | } else {
67 | console.error("Challenge ID not found in the URL.");
68 | }
69 |
--------------------------------------------------------------------------------
/assets/view.html:
--------------------------------------------------------------------------------
1 | {% extends "challenge.html" %}
2 |
3 | {% block connection_info %}
4 |
5 | ![]()
6 |
7 |
8 |
11 |
14 |
17 |
18 |
19 | {% endblock %}
--------------------------------------------------------------------------------
/assets/view.js:
--------------------------------------------------------------------------------
1 | CTFd._internal.challenge.data = undefined;
2 |
3 | CTFd._internal.challenge.renderer = null;
4 |
5 | CTFd._internal.challenge.preRender = function () {};
6 |
7 | CTFd._internal.challenge.render = null;
8 |
9 | CTFd._internal.challenge.postRender = function () {};
10 |
11 | CTFd._internal.challenge.submit = function (preview) {
12 | var challenge_id = parseInt(CTFd.lib.$("#challenge-id").val());
13 | var submission = CTFd.lib.$("#challenge-input").val();
14 |
15 | let alert = resetAlert();
16 |
17 | var body = {
18 | challenge_id: challenge_id,
19 | submission: submission,
20 | };
21 | var params = {};
22 | if (preview) {
23 | params["preview"] = true;
24 | }
25 |
26 | return CTFd.api
27 | .post_challenge_attempt(params, body)
28 | .then(function (response) {
29 | if (response.status === 429) {
30 | // User was ratelimited but process response
31 | return response;
32 | }
33 | if (response.status === 403) {
34 | // User is not logged in or CTF is paused.
35 | return response;
36 | }
37 | return response;
38 | });
39 | };
40 |
41 | function mergeQueryParams(parameters, queryParameters) {
42 | if (parameters.$queryParameters) {
43 | Object.keys(parameters.$queryParameters).forEach(function (
44 | parameterName
45 | ) {
46 | var parameter = parameters.$queryParameters[parameterName];
47 | queryParameters[parameterName] = parameter;
48 | });
49 | }
50 |
51 | return queryParameters;
52 | }
53 |
54 | function resetAlert() {
55 | let alert = document.getElementById("deployment-info");
56 | alert.innerHTML = "";
57 | alert.classList.remove("alert-danger");
58 | return alert;
59 | }
60 |
61 | function toggleChallengeCreate() {
62 | let btn = document.getElementById("create-chal");
63 | btn.classList.toggle('d-none');
64 | }
65 |
66 | function toggleChallengeUpdate() {
67 | let btn = document.getElementById("extend-chal");
68 | btn.classList.toggle('d-none');
69 |
70 | btn = document.getElementById("terminate-chal");
71 | btn.classList.toggle('d-none');
72 | }
73 |
74 | function calculateExpiry(date) {
75 | // Get the difference in minutes
76 | let difference = Math.ceil(
77 | (new Date(date * 1000) - new Date()) / 1000 / 60
78 | );;
79 | return difference;
80 | }
81 |
82 | function createChallengeLinkElement(data, parent) {
83 |
84 | var expires = document.createElement('span');
85 | expires.textContent = "Suffering ends in " + calculateExpiry(new Date(data.expires)) + " minutes.";
86 |
87 | parent.append(expires);
88 | parent.append(document.createElement('br'));
89 |
90 | if (data.connect == "tcp") {
91 | let codeElement = document.createElement('code');
92 | codeElement.textContent = 'nc ' + data.hostname + " " + data.port;
93 | parent.append(codeElement);
94 | } else if(data.connect == "ssh") {
95 | let codeElement = document.createElement('code');
96 | // In case you have to get the password from other sources
97 | if(data.ssh_password == null) {
98 | codeElement.textContent = 'ssh -o StrictHostKeyChecking=no ' + data.ssh_username + '@' + data.hostname + " -p" + data.port;
99 | } else {
100 | codeElement.textContent = 'sshpass -p' + data.ssh_password + " ssh -o StrictHostKeyChecking=no " + data.ssh_username + '@' + data.hostname + " -p" + data.port;
101 | }
102 | parent.append(codeElement);
103 | } else {
104 | let link = document.createElement('a');
105 | link.href = 'http://' + data.hostname + ":" + data.port;
106 | link.textContent = 'http://' + data.hostname + ":" + data.port;
107 | link.target = '_blank'
108 | parent.append(link);
109 | }
110 | }
111 |
112 | function view_container_info(challenge_id) {
113 | resetAlert();
114 | var path = "/containers/api/view_info";
115 |
116 | let alert = document.getElementById("deployment-info");
117 | fetch(path, {
118 | method: "POST",
119 | headers: {
120 | "Content-Type": "application/json",
121 | "Accept": "application/json",
122 | "CSRF-Token": init.csrfNonce
123 | },
124 | body: JSON.stringify({ chal_id: challenge_id })
125 | })
126 | .then(response => response.json())
127 | .then(data => {
128 | if (data.status == "Suffering hasn't begun") {
129 | alert.append(data.status);
130 | toggleChallengeCreate();
131 | } else if (data.status == "already_running") {
132 | // Success
133 | createChallengeLinkElement(data, alert);
134 | toggleChallengeUpdate();
135 | } else {
136 | resetAlert();
137 | alert.append(data.message);
138 | alert.classList.toggle('alert-danger');
139 | toggleChallengeUpdate();
140 | }
141 | })
142 | .catch(error => {
143 | console.error("Fetch error:", error);
144 | });
145 | }
146 |
147 | function container_request(challenge_id) {
148 | var path = "/containers/api/request";
149 | let alert = resetAlert();
150 |
151 | fetch(path, {
152 | method: "POST",
153 | headers: {
154 | "Content-Type": "application/json",
155 | "Accept": "application/json",
156 | "CSRF-Token": init.csrfNonce
157 | },
158 | body: JSON.stringify({ chal_id: challenge_id })
159 | })
160 | .then(response => response.json())
161 | .then(data => {
162 | if (data.error !== undefined) {
163 | // Container error
164 | alert.append(data.error);
165 | alert.classList.toggle('alert-danger');
166 | toggleChallengeCreate();
167 | } else if (data.message !== undefined) {
168 | // CTFd error
169 | alert.append(data.message);
170 | alert.classList.toggle('alert-danger');
171 | toggleChallengeCreate();
172 | } else {
173 | // Success
174 | createChallengeLinkElement(data, alert);
175 | toggleChallengeUpdate();
176 | toggleChallengeCreate();
177 | }
178 | })
179 | .catch(error => {
180 | console.error("Fetch error:", error);
181 | });
182 | }
183 |
184 | function container_renew(challenge_id) {
185 | var path = "/containers/api/renew";
186 | let alert = resetAlert();
187 |
188 | fetch(path, {
189 | method: "POST",
190 | headers: {
191 | "Content-Type": "application/json",
192 | "Accept": "application/json",
193 | "CSRF-Token": init.csrfNonce
194 | },
195 | body: JSON.stringify({ chal_id: challenge_id })
196 | })
197 | .then(response => response.json())
198 | .then(data => {
199 | if (data.error !== undefined) {
200 | // Container error
201 | alert.append(data.error);
202 | alert.classList.toggle('alert-danger');
203 | toggleChallengeCreate();
204 | } else if (data.message !== undefined) {
205 | // CTFd error
206 | alert.append(data.message);
207 | alert.classList.toggle('alert-danger');
208 | toggleChallengeCreate();
209 | } else {
210 | // Success
211 | createChallengeLinkElement(data, alert);
212 | }
213 | })
214 | .catch(error => {
215 | console.error("Fetch error:", error);
216 | });
217 | }
218 |
219 | function container_stop(challenge_id) {
220 | var path = "/containers/api/stop";
221 | let alert = resetAlert();
222 |
223 | fetch(path, {
224 | method: "POST",
225 | headers: {
226 | "Content-Type": "application/json",
227 | "Accept": "application/json",
228 | "CSRF-Token": init.csrfNonce
229 | },
230 | body: JSON.stringify({ chal_id: challenge_id })
231 | })
232 | .then(response => response.json())
233 | .then(data => {
234 | if (data.error !== undefined) {
235 | // Container error
236 | alert.append(data.error);
237 | alert.classList.toggle('alert-danger');
238 | toggleChallengeCreate();
239 | } else if (data.message !== undefined) {
240 | // CTFd error
241 | alert.append(data.message);
242 | alert.classList.toggle('alert-danger');
243 | toggleChallengeCreate();
244 | } else {
245 | // Success
246 | alert.append("You have suffered enough.");
247 | toggleChallengeCreate();
248 | toggleChallengeUpdate();
249 | }
250 | })
251 | .catch(error => {
252 | console.error("Fetch error:", error);
253 | });
254 | }
255 |
256 |
--------------------------------------------------------------------------------
/config.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "Containers",
3 | "route": "/containers/dashboard"
4 | }
5 |
--------------------------------------------------------------------------------
/container_manager.py:
--------------------------------------------------------------------------------
1 | import atexit
2 | import time
3 | import json
4 |
5 | from flask import Flask
6 | from apscheduler.schedulers.background import BackgroundScheduler
7 | from apscheduler.schedulers import SchedulerNotRunningError
8 | import docker
9 | import paramiko.ssh_exception
10 | import requests
11 | import socket
12 | import random
13 |
14 | from CTFd.models import db
15 | from .models import ContainerInfoModel
16 |
17 | """ To those who will just copy instead of forking, atleast give credits to the author and change your commit messages ;) """
18 | class ContainerException(Exception):
19 | def __init__(self, *args: object) -> None:
20 | super().__init__(*args)
21 | if args:
22 | self.message = args[0]
23 | else:
24 | self.message = None
25 |
26 | def __str__(self) -> str:
27 | if self.message:
28 | return self.message
29 | else:
30 | return "Unknown Container Exception"
31 |
32 | class ContainerManager:
33 | def __init__(self, settings, app):
34 | self.settings = settings
35 | self.client = None
36 | self.app = app
37 | if settings.get("docker_base_url") is None or settings.get("docker_base_url") == "":
38 | return
39 |
40 | # Connect to the docker daemon
41 | try:
42 | self.initialize_connection(settings, app)
43 | except ContainerException:
44 | print("Docker could not initialize or connect.")
45 | return
46 |
47 | def __check_port__(self, port: int) -> bool:
48 | s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
49 | s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
50 | s.settimeout(1)
51 | try:
52 | s.bind(("0.0.0.0", port))
53 | s.close()
54 | return True
55 | except Exception as e:
56 | print(f"Error when fetching port: {e}")
57 | return False
58 |
59 | def initialize_connection(self, settings, app) -> None:
60 | self.settings = settings
61 | self.app = app
62 |
63 | # Remove any leftover expiration schedulers
64 | try:
65 | self.expiration_scheduler.shutdown()
66 | except (SchedulerNotRunningError, AttributeError):
67 | # Scheduler was never running
68 | pass
69 |
70 | if settings.get("docker_base_url") is None:
71 | self.client = None
72 | return
73 |
74 | try:
75 | self.client = docker.DockerClient(
76 | base_url=settings.get("docker_base_url"))
77 | except (docker.errors.DockerException) as e:
78 | self.client = None
79 | print(f"Error: {e}")
80 | raise ContainerException("CTFd could not connect to Docker")
81 | except TimeoutError as e:
82 | self.client = None
83 | raise ContainerException(
84 | "CTFd timed out when connecting to Docker")
85 | except paramiko.ssh_exception.NoValidConnectionsError as e:
86 | self.client = None
87 | raise ContainerException(
88 | "CTFd timed out when connecting to Docker: " + str(e))
89 | except paramiko.ssh_exception.AuthenticationException as e:
90 | self.client = None
91 | raise ContainerException(
92 | "CTFd had an authentication error when connecting to Docker: " + str(e))
93 |
94 | # Set up expiration scheduler
95 | try:
96 | self.expiration_seconds = int(
97 | settings.get("container_expiration", 0)) * 60
98 | except (ValueError, AttributeError):
99 | self.expiration_seconds = 0
100 |
101 | EXPIRATION_CHECK_INTERVAL = 5
102 |
103 | if self.expiration_seconds > 0:
104 | self.expiration_scheduler = BackgroundScheduler()
105 | self.expiration_scheduler.add_job(
106 | func=self.kill_expired_containers, args=(app,), trigger="interval", seconds=EXPIRATION_CHECK_INTERVAL)
107 | self.expiration_scheduler.start()
108 |
109 | # Shut down the scheduler when exiting the app
110 | atexit.register(lambda: self.expiration_scheduler.shutdown())
111 |
112 | # TODO: Fix this cause it doesn't work
113 | def run_command(func):
114 | def wrapper_run_command(self, *args, **kwargs):
115 | if self.client is None:
116 | try:
117 | self.__init__(self.settings, self.app)
118 | except:
119 | raise ContainerException("Docker is not connected")
120 | try:
121 | if self.client is None:
122 | raise ContainerException("Docker is not connected")
123 | if self.client.ping():
124 | return func(self, *args, **kwargs)
125 | except (paramiko.ssh_exception.SSHException, ConnectionError, requests.exceptions.ConnectionError) as e:
126 | # Try to reconnect before failing
127 | try:
128 | self.__init__(self.settings, self.app)
129 | except:
130 | pass
131 | raise ContainerException(
132 | "Docker connection was lost. Please try your request again later.")
133 | return wrapper_run_command
134 |
135 | @run_command
136 | def kill_expired_containers(self, app: Flask):
137 | with app.app_context():
138 | containers: "list[ContainerInfoModel]" = ContainerInfoModel.query.all()
139 |
140 | for container in containers:
141 | delta_seconds = container.expires - int(time.time())
142 | if delta_seconds < 0:
143 | try:
144 | self.kill_container(container.container_id)
145 | except ContainerException:
146 | print(
147 | "[Container Expiry Job] Docker is not initialized. Please check your settings.")
148 |
149 | db.session.delete(container)
150 | db.session.commit()
151 |
152 | @run_command
153 | def is_container_running(self, container_id: str) -> bool:
154 | container = self.client.containers.list(filters={"id": container_id})
155 | if len(container) == 0:
156 | return False
157 | return container[0].status == "running"
158 |
159 | @run_command
160 | def create_container(self, chal_id: str, team_id: str, user_id: str, image: str, port: int, command: str, volumes: str):
161 | kwargs = {}
162 |
163 | # Set the memory and CPU limits for the container
164 | if self.settings.get("container_maxmemory"):
165 | try:
166 | mem_limit = int(self.settings.get("container_maxmemory"))
167 | if mem_limit > 0:
168 | kwargs["mem_limit"] = f"{mem_limit}m"
169 | except ValueError:
170 | ContainerException(
171 | "Configured container memory limit must be an integer")
172 | if self.settings.get("container_maxcpu"):
173 | try:
174 | cpu_period = float(self.settings.get("container_maxcpu"))
175 | if cpu_period > 0:
176 | kwargs["cpu_quota"] = int(cpu_period * 100000)
177 | kwargs["cpu_period"] = 100000
178 | except ValueError:
179 | ContainerException(
180 | "Configured container CPU limit must be a number")
181 |
182 | if volumes is not None and volumes != "":
183 | print("Volumes:", volumes)
184 | try:
185 | volumes_dict = json.loads(volumes)
186 | kwargs["volumes"] = volumes_dict
187 | except json.decoder.JSONDecodeError:
188 | raise ContainerException("Volumes JSON string is invalid")
189 |
190 | external_port = random.randint(port, 65535)
191 | while not self.__check_port__(external_port):
192 | external_port = random.randint(port, 65535)
193 |
194 | print(f"Using {external_port} as the external port for challenge {chal_id} for team {team_id} spawned by {user_id}")
195 | try:
196 | return self.client.containers.run(
197 | image,
198 | ports={str(port): str(external_port)},
199 | command=command,
200 | detach=True,
201 | auto_remove=True,
202 | environment={"CHALLENGE_ID": chal_id, "TEAM_ID": team_id, "USER_ID": user_id},
203 | **kwargs
204 | )
205 | except docker.errors.ImageNotFound:
206 | raise ContainerException("Docker image not found")
207 |
208 | @run_command
209 | def get_container_port(self, container_id: str) -> "str|None":
210 | try:
211 | for port in list(self.client.containers.get(container_id).ports.values()):
212 | if port is not None:
213 | return port[0]["HostPort"]
214 | except (KeyError, IndexError):
215 | return None
216 |
217 | @run_command
218 | def get_images(self) -> "list[str]|None":
219 | try:
220 | images = self.client.images.list()
221 | except (KeyError, IndexError):
222 | return []
223 |
224 | images_list = []
225 | for image in images:
226 | if len(image.tags) > 0:
227 | images_list.append(image.tags[0])
228 |
229 | images_list.sort()
230 | return images_list
231 |
232 | @run_command
233 | def kill_container(self, container_id: str):
234 | try:
235 | self.client.containers.get(container_id).kill()
236 | except docker.errors.NotFound:
237 | pass
238 |
239 | def is_connected(self) -> bool:
240 | try:
241 | self.client.ping()
242 | except:
243 | return False
244 | return True
245 |
--------------------------------------------------------------------------------
/image-readme/1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TheFlash2k/containers/b8cf27c5d8224e8e987fde7391c9ab9c48e02b7c/image-readme/1.png
--------------------------------------------------------------------------------
/image-readme/2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TheFlash2k/containers/b8cf27c5d8224e8e987fde7391c9ab9c48e02b7c/image-readme/2.png
--------------------------------------------------------------------------------
/image-readme/3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TheFlash2k/containers/b8cf27c5d8224e8e987fde7391c9ab9c48e02b7c/image-readme/3.png
--------------------------------------------------------------------------------
/image-readme/4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TheFlash2k/containers/b8cf27c5d8224e8e987fde7391c9ab9c48e02b7c/image-readme/4.png
--------------------------------------------------------------------------------
/image-readme/demo.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TheFlash2k/containers/b8cf27c5d8224e8e987fde7391c9ab9c48e02b7c/image-readme/demo.gif
--------------------------------------------------------------------------------
/image-readme/http.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TheFlash2k/containers/b8cf27c5d8224e8e987fde7391c9ab9c48e02b7c/image-readme/http.png
--------------------------------------------------------------------------------
/image-readme/main.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TheFlash2k/containers/b8cf27c5d8224e8e987fde7391c9ab9c48e02b7c/image-readme/main.png
--------------------------------------------------------------------------------
/image-readme/manage.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TheFlash2k/containers/b8cf27c5d8224e8e987fde7391c9ab9c48e02b7c/image-readme/manage.png
--------------------------------------------------------------------------------
/image-readme/tcp.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TheFlash2k/containers/b8cf27c5d8224e8e987fde7391c9ab9c48e02b7c/image-readme/tcp.png
--------------------------------------------------------------------------------
/models.py:
--------------------------------------------------------------------------------
1 | from sqlalchemy.sql import func
2 | from sqlalchemy.orm import relationship
3 |
4 | from CTFd.models import db
5 | from CTFd.models import Challenges
6 |
7 |
8 | class ContainerChallengeModel(Challenges):
9 | __mapper_args__ = {"polymorphic_identity": "container"}
10 | id = db.Column(
11 | db.Integer, db.ForeignKey("challenges.id", ondelete="CASCADE"), primary_key=True
12 | )
13 | image = db.Column(db.Text)
14 | port = db.Column(db.Integer)
15 | command = db.Column(db.Text, default="")
16 | volumes = db.Column(db.Text, default="")
17 | ctype = db.Column(db.Text, default="tcp")
18 |
19 | ssh_username = db.Column(db.Text, nullable=True)
20 | ssh_password = db.Column(db.Text, nullable=True)
21 |
22 | # Dynamic challenge properties
23 | initial = db.Column(db.Integer, default=0)
24 | minimum = db.Column(db.Integer, default=0)
25 | decay = db.Column(db.Integer, default=0)
26 |
27 | def __init__(self, *args, **kwargs):
28 | super(ContainerChallengeModel, self).__init__(**kwargs)
29 | self.value = kwargs["initial"]
30 |
31 |
32 | class ContainerInfoModel(db.Model):
33 | __mapper_args__ = {"polymorphic_identity": "container_info"}
34 | container_id = db.Column(db.String(512), primary_key=True)
35 | challenge_id = db.Column(
36 | db.Integer, db.ForeignKey("challenges.id", ondelete="CASCADE")
37 | )
38 | team_id = db.Column(
39 | db.Integer, db.ForeignKey("teams.id", ondelete="CASCADE")
40 | )
41 | user_id = db.Column(
42 | db.Integer, db.ForeignKey("users.id", ondelete="CASCADE")
43 | )
44 | port = db.Column(db.Integer)
45 | ssh_username = db.Column(db.Text, nullable=True)
46 | ssh_password = db.Column(db.Text, nullable=True)
47 | timestamp = db.Column(db.Integer)
48 | expires = db.Column(db.Integer)
49 | team = relationship("Teams", foreign_keys=[team_id])
50 | user = relationship("Users", foreign_keys=[user_id])
51 | challenge = relationship(ContainerChallengeModel,
52 | foreign_keys=[challenge_id])
53 |
54 | class ContainerSettingsModel(db.Model):
55 | __mapper_args__ = {"polymorphic_identity": "container_settings"}
56 | key = db.Column(db.String(512), primary_key=True)
57 | value = db.Column(db.Text)
58 |
--------------------------------------------------------------------------------
/settings.json:
--------------------------------------------------------------------------------
1 | {
2 | "modes" : {
3 | "USERS_MODE": "users",
4 | "TEAMS_MODE": "teams"
5 | },
6 |
7 | "plugin-info" : {
8 | "id": "container",
9 | "name": "container",
10 | "templates" : {
11 | "create": "/plugins/containers/assets/create.html",
12 | "update": "/plugins/containers/assets/update.html",
13 | "view": "/plugins/containers/assets/view.html"
14 | },
15 | "scripts": {
16 | "create": "/plugins/containers/assets/create.js",
17 | "update": "/plugins/containers/assets/update.js",
18 | "view": "/plugins/containers/assets/view.js"
19 | },
20 | "route" : "/plugins/containers/assets/"
21 | },
22 |
23 | "requests" : {
24 | "limit": 500,
25 | "interval": 10
26 | },
27 |
28 | "vars" : {
29 | "MAX_CONTAINERS_ALLOWED": 4
30 | }
31 | }
--------------------------------------------------------------------------------
/templates/container_dashboard.html:
--------------------------------------------------------------------------------
1 | {% extends "admin/base.html" %}
2 |
3 |
4 | {% block content %}
5 |
6 |
16 |
17 |
18 |
22 |
19 |
21 | Containers
20 |
23 | {% with messages = get_flashed_messages() %}
24 | {% if messages %}
25 | {% for message in messages %}
26 |
70 | {% if containers %}
71 | {% for c in containers %}
72 |
73 |
124 |
125 |
126 | {% endblock %}
127 |
128 | {% block scripts %}
129 |
271 | {% endblock %}
--------------------------------------------------------------------------------
/templates/container_settings.html:
--------------------------------------------------------------------------------
1 | {% extends 'admin/base.html' %}
2 | {% block content %}
3 |
27 | {{ message }}
28 |
29 | {% endfor %}
30 | {% endif %}
31 | {% endwith %}
32 |
33 |
35 | Settings
37 |
38 | {% if connected %}
39 | Docker Connected
40 | {% else %}
41 | Docker Not Connected
42 | {% endif %}
43 |
44 |
45 |
46 |
68 |
69 |
47 |
67 |
48 |
55 |
49 |
53 |
54 |
56 |
63 |
57 |
61 |
62 |
64 |
65 |
66 | | Container ID 75 | | 76 |Image 77 | | 78 |Challenge 79 | | 80 | {% if c.team == None %} 81 |User | 82 | {% else %} 83 |User | 84 |Team | 85 | {% endif %} 86 |Port 87 | | 88 |Created 89 | | 90 |Expires 91 | | 92 |Running 93 | | 94 |Kill 95 | | |
| {{ c.container_id[:12] }} | 101 |{{ c.challenge.image }} | 102 |{{ c.challenge.name }} [{{ c.challenge_id }}] | 103 | {% if c.team == None %} 104 |{{ c.user.name }} [{{ c.user_id }}] | 105 | {% else %} 106 |{{ c.user.name }} [{{ c.user_id }}] | 107 |{{ c.team.name }} [{{ c.team_id }}] | 108 | {% endif %} 109 |{{ c.port }} | 110 |{{ c.timestamp|format_time }} | 111 |{{ c.expires|format_time }} | 112 | {% if c.is_running %} 113 |Yes | 114 | {% else %} 115 |No | 116 | {% endif %} 117 |119 | |
4 |
8 |
5 |
7 | Docker Config
6 |
9 | {% with messages = get_flashed_messages() %}
10 | {% if messages %}
11 | {% for message in messages %}
12 |
77 | {% endblock content %}
78 | {% block scripts %}
79 |
84 | {% endblock scripts %}
--------------------------------------------------------------------------------
13 | {{ message }}
14 |
15 | {% endfor %}
16 | {% endif %}
17 | {% endwith %}
18 |
19 |
68 |
20 |
65 |
66 |
67 | Instructions
69 |
70 | The Base URL should be the local socket address of the Docker daemon, i.e.
71 | unix://var/run/docker.sock, or it can be a remote SSH address, e.g.
72 | ssh://root@example.com. In either case, sudo will not be executed. For a local socket, the user
73 | CTFd is running as should have permissions for Docker; for SSH connections, the SSH user in the Base URL should
74 | be root or have Docker permissions.
75 |