def create_app(): app = Flask("CTFd", static_folder="../static", template_folder="../templates") with app.app_context(): app.config.from_object('CTFd.config') app.permanent_session_lifetime = timedelta(minutes=30) from CTFd.models import db, Users, EquipmentsStatus from CTFd import models db.init_app(app) db.create_all() app.db = db # app.setup = True global mail mail = Mail(app) Session(app) from CTFd.views import init_views init_views(app) from CTFd.errors import init_errors init_errors(app) from CTFd import auth auth.init_auth(app) from CTFd import panSky panSky.init_views(app) #from CTFd.auth import init_auth #init_auth(app) from CTFd.utils import init_utils init_utils(app) return app
def create_app(config='CTFd.config'): app = Flask("CTFd") with app.app_context(): app.config.from_object(config) from CTFd.models import db, Teams, Solves, Challenges, WrongKeys, Keys, Tags, Files, Tracking db.init_app(app) db.create_all() app.db = db global mail mail = Mail(app) Session(app) from CTFd.views import views from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin from CTFd.utils import init_utils, init_errors, init_logs init_utils(app) init_errors(app) init_logs(app) app.register_blueprint(views) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(admin) return app
def create_app(config='CTFd.config'): app = Flask("CTFd") with app.app_context(): app.config.from_object(config) from CTFd.models import db, Teams, Solves, Challenges, WrongKeys, Keys, Tags, Files, Tracking db.init_app(app) db.create_all() app.db = db global mail mail = Mail(app) #Session(app) from CTFd.views import views from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin from CTFd.utils import init_utils, init_errors, init_logs init_utils(app) init_errors(app) init_logs(app) app.register_blueprint(views) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(admin) return app
def create_app(config='CTFd.config'): app = Flask("CTFd") with app.app_context(): app.config.from_object(config) from CTFd.models import db, Teams, Solves, Challenges, WrongKeys, Keys, Tags, Files, Tracking, mysql app.config['MYSQL_DATABASE_USER'] = '******' app.config['MYSQL_DATABASE_PASSWORD'] = '******' app.config['MYSQL_DATABASE_DB'] = 'EmpData' app.config['MYSQL_DATABASE_HOST'] = 'localhost' mysql.init_app(app) cursor = mysql.connection.cursor() # cursor.execute('CREATE DATABASE IF NOT EXISTS info_sec;') # cursor.execute('USE info_sec;') # cursor.execute('CREATE TABLE IF NOT EXISTS info_sec.security_table \ # (\ # username varchar(255),\ # pass char(255));') db.init_app(app) db.create_all() app.db = db #Session(app) from CTFd.views import views from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin from CTFd.utils import init_utils, init_errors, init_logs init_utils(app) init_errors(app) init_logs(app) app.register_blueprint(views) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(admin) return app
def load(app): vm_pages = Blueprint('virtual_machines', __name__) db.create_all() # Clean and recreate the vm table for debugging # XXX: Remove this VMs.query.delete() db.session.add( VMs( "Test Virtual Machine", 1, "This is a test virtual machine for a challenge. To access, run `ssh [email protected]` the password is `user`" )) db.session.commit() db.session.close() # Route for the VM page @vm_pages.route('/vm/', methods=['GET']) def virtual_machines_view(): # Check if authed if not utils.authed() or not 'id' in session: return redirect(url_for('auth.login', next='vm')) # Look for all vms that the team has access too (has solved the chal) vmso = VMs.query.join(Solves, Solves.teamid == int( session['id'])).filter(Solves.chalid == VMs.chalid).all() vms = [] # Set up the json data for v in vmso: signer = Signer(utils.get_config('VM_KEY'), salt=v.name, digest_method=sha256) vms.append({ 'name': v.name, 'desc': v.desc, 'key': signer.sign(json.dumps({ 'team': session['id'], 'vm': v.name })).encode('base64').replace('\n', '') }) # Run the template return render_template(PLUGIN_NAME + '/vms.html', vms=vms) app.register_blueprint(vm_pages)
def create_app(subdomain="", username="", password=""): app = Flask("CTFd", static_folder="../static", template_folder="../templates") with app.app_context(): app.config.from_object('CTFd.config') if subdomain: app.config.update( SQLALCHEMY_DATABASE_URI = 'mysql://'+username+':'+password+'@localhost:3306/' + subdomain + '_ctfd', HOST = subdomain + app.config["HOST"], SESSION_FILE_DIR = app.config['SESSION_FILE_DIR'] + "/" + subdomain, DEBUG = True ) from CTFd.models import db, Teams, Solves, Challenges, WrongKeys, Keys, Tags, Files, Tracking db.init_app(app) db.create_all() app.db = db # app.setup = True global mail mail = Mail(app) #instead of using default Flask session which does not support regenerate, we use kvsession #for some reason FilesystemStore does not create the directory..... weird, but fixed by creating the dir here. if not os.path.exists(app.config['SESSION_FILE_DIR']): os.makedirs(app.config['SESSION_FILE_DIR']) store = FilesystemStore(app.config['SESSION_FILE_DIR']) KVSessionExtension(store, app) from CTFd.views import init_views init_views(app) from CTFd.errors import init_errors init_errors(app) from CTFd.challenges import init_challenges init_challenges(app) from CTFd.scoreboard import init_scoreboard init_scoreboard(app) from CTFd.auth import init_auth init_auth(app) from CTFd.admin import init_admin init_admin(app) from CTFd.utils import init_utils init_utils(app) return app
def create_app(subdomain="", username="", password=""): app = Flask("CTFd", static_folder="../static", template_folder="../templates") with app.app_context(): app.config.from_object('CTFd.config') if subdomain: app.config.update( SQLALCHEMY_DATABASE_URI='mysql://' + username + ':' + password + '@localhost:3306/' + subdomain + '_ctfd', HOST=subdomain + app.config["HOST"], SESSION_FILE_DIR=app.config['SESSION_FILE_DIR'] + "/" + subdomain, DEBUG=True) from CTFd.models import db, Teams, Solves, Challenges, WrongKeys, Keys, Tags, Files, Tracking db.init_app(app) db.create_all() app.db = db # app.setup = True global mail mail = Mail(app) Session(app) from CTFd.views import init_views init_views(app) from CTFd.errors import init_errors init_errors(app) from CTFd.challenges import init_challenges init_challenges(app) from CTFd.scoreboard import init_scoreboard init_scoreboard(app) from CTFd.auth import init_auth init_auth(app) from CTFd.admin import init_admin init_admin(app) from CTFd.utils import init_utils init_utils(app) return app
def create_app(config='CTFd.config'): app = Flask(__name__) with app.app_context(): app.config.from_object(config) app.jinja_loader = ThemeLoader(os.path.join(app.root_path, app.template_folder), followlinks=True) from CTFd.models import db, Teams, Solves, Challenges, WrongKeys, Keys, Tags, Files, Tracking ## sqlite database creation is relative to the script which causes issues with serve.py if not database_exists( app.config['SQLALCHEMY_DATABASE_URI'] ) and not app.config['SQLALCHEMY_DATABASE_URI'].startswith('sqlite'): create_database(app.config['SQLALCHEMY_DATABASE_URI']) db.init_app(app) db.create_all() app.db = db if not get_config('ctf_theme'): set_config('ctf_theme', 'original') #Session(app) from CTFd.views import views from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin from CTFd.utils import init_utils, init_errors, init_logs init_utils(app) init_errors(app) init_logs(app) app.register_blueprint(views) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(admin) return app
def load(app): dir_path = os.path.dirname(os.path.realpath(__file__)) db.create_all() register_plugin_assets_directory( app, base_path="/plugins/CTFd-pwn-college-plugin/assets/") CHALLENGE_CLASSES["docker"] = DockerChallenge FLAG_CLASSES["user"] = UserFlag ssh_key_template_path = os.path.join(dir_path, "assets", "ssh_key", "settings.html") override_template("settings.html", open(ssh_key_template_path).read()) app.view_functions["views.settings"] = ssh_key_settings Forms.keys = {"SSHKeyForm": SSHKeyForm} scoreboard_template_path = os.path.join(dir_path, "assets", "scoreboard", "scoreboard.html") override_template("scoreboard.html", open(scoreboard_template_path).read()) app.view_functions["scoreboard.listing"] = scoreboard_listing blueprint = Blueprint("pwncollege_api", __name__) api = Api(blueprint, version="v1", doc=current_app.config.get("SWAGGER_UI")) api.add_namespace(docker_namespace, "/docker") api.add_namespace(user_flag_namespace, "/user_flag") api.add_namespace(ssh_key_namespace, "/ssh_key") api.add_namespace(download_namespace, "/download") api.add_namespace(terminal_namespace, "/terminal") api.add_namespace(binary_ninja_namespace, "/binary_ninja") api.add_namespace(belts_namespace, "/belts") app.register_blueprint(blueprint, url_prefix="/pwncollege_api/v1") app.register_blueprint(download) app.register_blueprint(terminal) register_user_page_menu_bar("Terminal", "/terminal") app.register_blueprint(grades) register_user_page_menu_bar("Grades", "/grades") register_admin_plugin_menu_bar("Grades", "/grades/all")
def create_app(subdomain="", username="", password=""): app = Flask("CTFd", static_folder="../static", template_folder="../templates") with app.app_context(): app.config.from_object('CTFd.config') if subdomain: app.config.update( SQLALCHEMY_DATABASE_URI = 'mysql://'+username+':'+password+'@localhost:3306/' + subdomain + '_ctfd', HOST = subdomain + app.config["HOST"], SESSION_FILE_DIR = app.config['SESSION_FILE_DIR'] + "/" + subdomain, DEBUG = True ) from CTFd.models import db, Teams, Solves, Challenges, WrongKeys, Keys, Tags, Files, Tracking db.init_app(app) db.create_all() app.db = db # app.setup = True global mail mail = Mail(app) Session(app) from CTFd.views import init_views init_views(app) from CTFd.errors import init_errors init_errors(app) from CTFd.challenges import init_challenges init_challenges(app) from CTFd.scoreboard import init_scoreboard init_scoreboard(app) from CTFd.auth import init_auth init_auth(app) from CTFd.admin import init_admin init_admin(app) from CTFd.utils import init_utils init_utils(app) return app
def create_app(config='CTFd.config'): app = Flask(__name__) with app.app_context(): app.config.from_object(config) app.jinja_loader = ThemeLoader(os.path.join(app.root_path, app.template_folder), followlinks=True) from CTFd.models import db, Teams, Solves, Challenges, WrongKeys, Keys, Tags, Files, Tracking url = make_url(app.config['SQLALCHEMY_DATABASE_URI']) if url.drivername == 'postgres': url.drivername = 'postgresql' db.init_app(app) try: if not (url.drivername.startswith('sqlite') or database_exists(url)): create_database(url) db.create_all() except OperationalError: db.create_all() except ProgrammingError: ## Database already exists pass else: db.create_all() app.db = db cache.init_app(app) app.cache = cache if not get_config('ctf_theme'): set_config('ctf_theme', 'original') #Session(app) from CTFd.views import views from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin from CTFd.utils import init_utils, init_errors, init_logs init_utils(app) init_errors(app) init_logs(app) app.register_blueprint(views) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(admin) from CTFd.plugins import init_plugins init_plugins(app) return app
def create_app(config='CTFd.config'): app = Flask(__name__) with app.app_context(): app.config.from_object(config) app.jinja_loader = ThemeLoader(os.path.join(app.root_path, app.template_folder), followlinks=True) from CTFd.models import db, Teams, Solves, Challenges, WrongKeys, Keys, Tags, Files, Tracking ## sqlite database creation is relative to the script which causes issues with serve.py if not database_exists(app.config['SQLALCHEMY_DATABASE_URI']) and not app.config['SQLALCHEMY_DATABASE_URI'].startswith('sqlite'): create_database(app.config['SQLALCHEMY_DATABASE_URI']) db.init_app(app) db.create_all() app.db = db if not get_config('ctf_theme'): set_config('ctf_theme', 'original') #Session(app) from CTFd.views import views from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin from CTFd.utils import init_utils, init_errors, init_logs init_utils(app) init_errors(app) init_logs(app) app.register_blueprint(views) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(admin) return app
def create_app(config="CTFd.config"): app = Flask("CTFd") with app.app_context(): app.config.from_object(config) from CTFd.models import db, Teams, Solves, Challenges, WrongKeys, Keys, Tags, Files, Tracking ## sqlite database creation is relative to the script which causes issues with serve.py if not database_exists(app.config["SQLALCHEMY_DATABASE_URI"]) and not app.config[ "SQLALCHEMY_DATABASE_URI" ].startswith("sqlite"): create_database(app.config["SQLALCHEMY_DATABASE_URI"]) db.init_app(app) db.create_all() app.db = db # Session(app) from CTFd.views import views from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin from CTFd.utils import init_utils, init_errors, init_logs init_utils(app) init_errors(app) init_logs(app) app.register_blueprint(views) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(admin) return app
def create_app(config='CTFd.config'): app = Flask("CTFd") with app.app_context(): app.config.from_object(config) from CTFd.models import db, Teams, Solves, Challenges, WrongKeys, Keys, Tags, Files, Tracking ## sqlite database creation is relative to the script which causes issues with serve.py if not database_exists( app.config['SQLALCHEMY_DATABASE_URI'] ) and not app.config['SQLALCHEMY_DATABASE_URI'].startswith('sqlite'): create_database(app.config['SQLALCHEMY_DATABASE_URI']) db.init_app(app) db.create_all() app.db = db #Session(app) from CTFd.views import views from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin from CTFd.utils import init_utils, init_errors, init_logs init_utils(app) init_errors(app) init_logs(app) app.register_blueprint(views) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(admin) return app
def create_app(config='CTFd.config.Config'): app = Flask(__name__) with app.app_context(): app.config.from_object(config) app.jinja_loader = ThemeLoader(os.path.join(app.root_path, 'themes'), followlinks=True) from CTFd.models import db, Teams, Solves, Challenges, WrongKeys, Keys, Tags, Files, Tracking url = make_url(app.config['SQLALCHEMY_DATABASE_URI']) if url.drivername == 'postgres': url.drivername = 'postgresql' if url.drivername.startswith('mysql'): url.query['charset'] = 'utf8mb4' # Creates database if the database database does not exist if not database_exists(url): if url.drivername.startswith('mysql'): create_database(url, encoding='utf8mb4') else: create_database(url) # This allows any changes to the SQLALCHEMY_DATABASE_URI to get pushed back in # This is mostly so we can force MySQL's charset app.config['SQLALCHEMY_DATABASE_URI'] = str(url) # Register database db.init_app(app) # Register Flask-Migrate migrate.init_app(app, db) # Alembic sqlite support is lacking so we should just create_all anyway if url.drivername.startswith('sqlite'): db.create_all() else: if len(db.engine.table_names()) == 0: # This creates tables instead of db.create_all() # Allows migrations to happen properly migrate_upgrade() elif 'alembic_version' not in db.engine.table_names(): # There is no alembic_version because CTFd is from before it had migrations # Stamp it to the base migration if confirm_upgrade(): migrate_stamp(revision='cb3cfcc47e2f') run_upgrade() else: exit() app.db = db app.VERSION = __version__ cache.init_app(app) app.cache = cache update_check() version = utils.get_config('ctf_version') # Upgrading from an older version of CTFd if version and (StrictVersion(version) < StrictVersion(__version__)): if confirm_upgrade(): run_upgrade() else: exit() if not utils.get_config('ctf_theme'): utils.set_config('ctf_theme', 'core') from CTFd.views import views from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin, admin_statistics, admin_challenges, admin_pages, admin_scoreboard, admin_keys, admin_teams from CTFd.utils import init_utils, init_errors, init_logs init_utils(app) init_errors(app) init_logs(app) app.register_blueprint(views) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(admin) app.register_blueprint(admin_statistics) app.register_blueprint(admin_challenges) app.register_blueprint(admin_teams) app.register_blueprint(admin_scoreboard) app.register_blueprint(admin_keys) app.register_blueprint(admin_pages) from CTFd.plugins import init_plugins init_plugins(app) return app
def create_app(config='CTFd.config.Config'): app = Flask(__name__) babel = Babel(app) app.config['BABEL_DEFAULT_LOCALE'] = 'hi' with app.app_context(): app.config.from_object(config) app.jinja_loader = ThemeLoader(os.path.join(app.root_path, app.template_folder), followlinks=True) from CTFd.models import db, Teams, Solves, Challenges, WrongKeys, Keys, Tags, Files, Tracking url = make_url(app.config['SQLALCHEMY_DATABASE_URI']) if url.drivername == 'postgres': url.drivername = 'postgresql' db.init_app(app) try: if not (url.drivername.startswith('sqlite') or database_exists(url)): create_database(url) db.create_all() except OperationalError: db.create_all() except ProgrammingError: ## Database already exists pass else: db.create_all() app.db = db migrate.init_app(app, db) app.config["CACHE_TYPE"] = "null" cache.init_app(app) app.cache = cache version = utils.get_config('ctf_version') if not version: ## Upgrading from an unversioned CTFd utils.set_config('ctf_version', __version__) if version and (StrictVersion(version) < StrictVersion(__version__) ): ## Upgrading from an older version of CTFd print("/*\\ CTFd has updated and must update the database! /*\\") print("/*\\ Please backup your database before proceeding! /*\\") print( "/*\\ CTFd maintainers are not responsible for any data loss! /*\\" ) if input('Run database migrations (Y/N)').lower().strip() == 'y': migrate_stamp() migrate_upgrade() utils.set_config('ctf_version', __version__) else: print('/*\\ Ignored database migrations... /*\\') exit() if not utils.get_config('ctf_theme'): utils.set_config('ctf_theme', 'original') from CTFd.views import views from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin, admin_statistics, admin_challenges, admin_pages, admin_scoreboard, admin_containers, admin_keys, admin_teams from CTFd.utils import init_utils, init_errors, init_logs init_utils(app) init_errors(app) init_logs(app) app.register_blueprint(views) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(admin) app.register_blueprint(admin_statistics) app.register_blueprint(admin_challenges) app.register_blueprint(admin_teams) app.register_blueprint(admin_scoreboard) app.register_blueprint(admin_keys) app.register_blueprint(admin_containers) app.register_blueprint(admin_pages) from CTFd.plugins import init_plugins init_plugins(app) return app
def create_app(config="CTFd.config.Config"): app = CTFdFlask(__name__) with app.app_context(): app.config.from_object(config) app.theme_loader = ThemeLoader(os.path.join(app.root_path, "themes"), followlinks=True) # Weird nested solution for accessing plugin templates app.plugin_loader = jinja2.PrefixLoader({ "plugins": jinja2.FileSystemLoader(searchpath=os.path.join( app.root_path, "plugins"), followlinks=True) }) # Load from themes first but fallback to loading from the plugin folder app.jinja_loader = jinja2.ChoiceLoader( [app.theme_loader, app.plugin_loader]) from CTFd.models import ( # noqa: F401 db, Teams, Solves, Challenges, Fails, Flags, Tags, Files, Tracking, ) url = create_database() # This allows any changes to the SQLALCHEMY_DATABASE_URI to get pushed back in # This is mostly so we can force MySQL's charset app.config["SQLALCHEMY_DATABASE_URI"] = str(url) # Register database db.init_app(app) # Register Flask-Migrate migrations.init_app(app, db) # Alembic sqlite support is lacking so we should just create_all anyway if url.drivername.startswith("sqlite"): # Enable foreign keys for SQLite. This must be before the # db.create_all call because tests use the in-memory SQLite # database (each connection, including db creation, is a new db). # https://docs.sqlalchemy.org/en/13/dialects/sqlite.html#foreign-key-support from sqlalchemy.engine import Engine from sqlalchemy import event @event.listens_for(Engine, "connect") def set_sqlite_pragma(dbapi_connection, connection_record): cursor = dbapi_connection.cursor() cursor.execute("PRAGMA foreign_keys=ON") cursor.close() db.create_all() stamp_latest_revision() else: # This creates tables instead of db.create_all() # Allows migrations to happen properly upgrade() from CTFd.models import ma ma.init_app(app) app.db = db app.VERSION = __version__ app.CHANNEL = __channel__ from CTFd.cache import cache cache.init_app(app) app.cache = cache reverse_proxy = app.config.get("REVERSE_PROXY") if reverse_proxy: if type(reverse_proxy) is str and "," in reverse_proxy: proxyfix_args = [int(i) for i in reverse_proxy.split(",")] app.wsgi_app = ProxyFix(app.wsgi_app, *proxyfix_args) else: app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1, x_proto=1, x_host=1, x_port=1, x_prefix=1) version = utils.get_config("ctf_version") # Upgrading from an older version of CTFd if version and (StrictVersion(version) < StrictVersion(__version__)): if confirm_upgrade(): run_upgrade() else: exit() if not version: utils.set_config("ctf_version", __version__) if not utils.get_config("ctf_theme"): utils.set_config("ctf_theme", "core") update_check(force=True) init_request_processors(app) init_template_filters(app) init_template_globals(app) # Importing here allows tests to use sensible names (e.g. api instead of api_bp) from CTFd.views import views from CTFd.teams import teams from CTFd.users import users from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin from CTFd.api import api from CTFd.events import events from CTFd.errors import page_not_found, forbidden, general_error, gateway_error app.register_blueprint(views) app.register_blueprint(teams) app.register_blueprint(users) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(api) app.register_blueprint(events) app.register_blueprint(admin) app.register_error_handler(404, page_not_found) app.register_error_handler(403, forbidden) app.register_error_handler(500, general_error) app.register_error_handler(502, gateway_error) init_logs(app) init_events(app) init_plugins(app) return app
def create_app(config='CTFd.config.Config'): app = Flask(__name__) with app.app_context(): app.config.from_object(config) app.jinja_loader = ThemeLoader(os.path.join(app.root_path, app.template_folder), followlinks=True) from CTFd.models import db, Teams, Solves, Challenges, WrongKeys, Keys, Tags, Files, Tracking url = make_url(app.config['SQLALCHEMY_DATABASE_URI']) if url.drivername == 'postgres': url.drivername = 'postgresql' # Creates database if the database database does not exist if not database_exists(url): create_database(url) # Register database db.init_app(app) # Register Flask-Migrate migrate.init_app(app, db) # This creates tables instead of db.create_all() # Allows migrations to happen properly migrate_upgrade() # Alembic sqlite support is lacking so we should just create_all anyway if url.drivername.startswith('sqlite'): db.create_all() app.db = db cache.init_app(app) app.cache = cache version = utils.get_config('ctf_version') if not version: # Upgrading from an unversioned CTFd utils.set_config('ctf_version', __version__) if version and (StrictVersion(version) < StrictVersion(__version__) ): # Upgrading from an older version of CTFd print("/*\\ CTFd has updated and must update the database! /*\\") print("/*\\ Please backup your database before proceeding! /*\\") print( "/*\\ CTFd maintainers are not responsible for any data loss! /*\\" ) if input('Run database migrations (Y/N)').lower().strip() == 'y': migrate_stamp() migrate_upgrade() utils.set_config('ctf_version', __version__) else: print('/*\\ Ignored database migrations... /*\\') exit() if not utils.get_config('ctf_theme'): utils.set_config('ctf_theme', 'original') from CTFd.views import views from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin, admin_statistics, admin_challenges, admin_pages, admin_scoreboard, admin_containers, admin_keys, admin_teams from CTFd.utils import init_utils, init_errors, init_logs init_utils(app) init_errors(app) init_logs(app) app.register_blueprint(views) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(admin) app.register_blueprint(admin_statistics) app.register_blueprint(admin_challenges) app.register_blueprint(admin_teams) app.register_blueprint(admin_scoreboard) app.register_blueprint(admin_keys) app.register_blueprint(admin_containers) app.register_blueprint(admin_pages) from CTFd.plugins import init_plugins init_plugins(app) return app
def create_app(config="CTFd.config.Config"): app = CTFdFlask(__name__) with app.app_context(): app.config.from_object(config) theme_loader = ThemeLoader(os.path.join(app.root_path, "themes"), followlinks=True) app.jinja_loader = theme_loader from CTFd.models import ( # noqa: F401 db, Teams, Solves, Challenges, Fails, Flags, Tags, Files, Tracking, ) url = create_database() # This allows any changes to the SQLALCHEMY_DATABASE_URI to get pushed back in # This is mostly so we can force MySQL's charset app.config["SQLALCHEMY_DATABASE_URI"] = str(url) # Register database db.init_app(app) # Register Flask-Migrate migrations.init_app(app, db) # Alembic sqlite support is lacking so we should just create_all anyway if url.drivername.startswith("sqlite"): db.create_all() stamp_latest_revision() else: # This creates tables instead of db.create_all() # Allows migrations to happen properly upgrade() from CTFd.models import ma ma.init_app(app) app.db = db app.VERSION = __version__ from CTFd.cache import cache cache.init_app(app) app.cache = cache reverse_proxy = app.config.get("REVERSE_PROXY") if reverse_proxy: if "," in reverse_proxy: proxyfix_args = [int(i) for i in reverse_proxy.split(",")] app.wsgi_app = ProxyFix(app.wsgi_app, None, *proxyfix_args) else: app.wsgi_app = ProxyFix( app.wsgi_app, num_proxies=None, x_for=1, x_proto=1, x_host=1, x_port=1, x_prefix=1, ) version = utils.get_config("ctf_version") # Upgrading from an older version of CTFd if version and (StrictVersion(version) < StrictVersion(__version__)): if confirm_upgrade(): run_upgrade() else: exit() if not version: utils.set_config("ctf_version", __version__) if not utils.get_config("ctf_theme"): utils.set_config("ctf_theme", "core") update_check(force=True) init_request_processors(app) init_template_filters(app) init_template_globals(app) # Importing here allows tests to use sensible names (e.g. api instead of api_bp) from CTFd.views import views from CTFd.teams import teams from CTFd.users import users from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin from CTFd.api import api from CTFd.events import events from CTFd.errors import page_not_found, forbidden, general_error, gateway_error app.register_blueprint(views) app.register_blueprint(teams) app.register_blueprint(users) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(api) app.register_blueprint(events) app.register_blueprint(admin) app.register_error_handler(404, page_not_found) app.register_error_handler(403, forbidden) app.register_error_handler(500, general_error) app.register_error_handler(502, gateway_error) init_logs(app) init_events(app) init_plugins(app) return app
def create_app(config='CTFd.config.Config'): app = Flask(__name__) with app.app_context(): app.config.from_object(config) app.jinja_loader = ThemeLoader(os.path.join(app.root_path, 'themes'), followlinks=True) from CTFd.models import db, Teams, Solves, Challenges, WrongKeys, Keys, Tags, Files, Tracking url = make_url(app.config['SQLALCHEMY_DATABASE_URI']) if url.drivername == 'postgres': url.drivername = 'postgresql' if url.drivername.startswith('mysql'): url.query['charset'] = 'utf8mb4' # Creates database if the database database does not exist if not database_exists(url): if url.drivername.startswith('mysql'): create_database(url, encoding='utf8mb4') else: create_database(url) # This allows any changes to the SQLALCHEMY_DATABASE_URI to get pushed back in # This is mostly so we can force MySQL's charset app.config['SQLALCHEMY_DATABASE_URI'] = str(url) # Register database db.init_app(app) # Register Flask-Migrate migrate.init_app(app, db) # This creates tables instead of db.create_all() # Allows migrations to happen properly migrate_upgrade() # Alembic sqlite support is lacking so we should just create_all anyway if url.drivername.startswith('sqlite'): db.create_all() app.db = db cache.init_app(app) app.cache = cache version = utils.get_config('ctf_version') if not version: # Upgrading from an unversioned CTFd utils.set_config('ctf_version', __version__) if version and (StrictVersion(version) < StrictVersion(__version__)): # Upgrading from an older version of CTFd print("/*\\ CTFd has updated and must update the database! /*\\") print("/*\\ Please backup your database before proceeding! /*\\") print("/*\\ CTFd maintainers are not responsible for any data loss! /*\\") if input('Run database migrations (Y/N)').lower().strip() == 'y': migrate_stamp() migrate_upgrade() utils.set_config('ctf_version', __version__) else: print('/*\\ Ignored database migrations... /*\\') exit() if not utils.get_config('ctf_theme'): utils.set_config('ctf_theme', 'original') from CTFd.views import views from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin, admin_statistics, admin_challenges, admin_pages, admin_scoreboard, admin_containers, admin_keys, admin_teams from CTFd.utils import init_utils, init_errors, init_logs init_utils(app) init_errors(app) init_logs(app) app.register_blueprint(views) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(admin) app.register_blueprint(admin_statistics) app.register_blueprint(admin_challenges) app.register_blueprint(admin_teams) app.register_blueprint(admin_scoreboard) app.register_blueprint(admin_keys) app.register_blueprint(admin_containers) app.register_blueprint(admin_pages) from CTFd.plugins import init_plugins init_plugins(app) return app
def create_app(config='CTFd.config.Config'): app = CTFdFlask(__name__) with app.app_context(): app.config.from_object(config) theme_loader = ThemeLoader(os.path.join(app.root_path, 'themes'), followlinks=True) app.jinja_loader = theme_loader from CTFd.models import db, Teams, Solves, Challenges, Fails, Flags, Tags, Files, Tracking url = create_database() # This allows any changes to the SQLALCHEMY_DATABASE_URI to get pushed back in # This is mostly so we can force MySQL's charset app.config['SQLALCHEMY_DATABASE_URI'] = str(url) # Register database db.init_app(app) # Register Flask-Migrate migrations.init_app(app, db) # Alembic sqlite support is lacking so we should just create_all anyway if url.drivername.startswith('sqlite'): db.create_all() stamp() else: # This creates tables instead of db.create_all() # Allows migrations to happen properly upgrade() from CTFd.models import ma ma.init_app(app) app.db = db app.VERSION = __version__ from CTFd.cache import cache cache.init_app(app) app.cache = cache # If you have multiple workers you must have a shared cache socketio.init_app(app, async_mode=app.config.get('SOCKETIO_ASYNC_MODE'), message_queue=app.config.get('CACHE_REDIS_URL')) if app.config.get('REVERSE_PROXY'): app.wsgi_app = ProxyFix(app.wsgi_app) version = utils.get_config('ctf_version') # Upgrading from an older version of CTFd if version and (StrictVersion(version) < StrictVersion(__version__)): if confirm_upgrade(): run_upgrade() else: exit() if not version: utils.set_config('ctf_version', __version__) if not utils.get_config('ctf_theme'): utils.set_config('ctf_theme', 'core') update_check(force=True) init_request_processors(app) init_template_filters(app) init_template_globals(app) # Importing here allows tests to use sensible names (e.g. api instead of api_bp) from CTFd.views import views from CTFd.teams import teams from CTFd.users import users from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin from CTFd.api import api from CTFd.events import events from CTFd.errors import page_not_found, forbidden, general_error, gateway_error app.register_blueprint(views) app.register_blueprint(teams) app.register_blueprint(users) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(api) app.register_blueprint(events) app.register_blueprint(admin) app.register_error_handler(404, page_not_found) app.register_error_handler(403, forbidden) app.register_error_handler(500, general_error) app.register_error_handler(502, gateway_error) init_plugins(app) return app
if __name__ == "__main__": args = parse_args() app = Flask(__name__) with app.app_context(): args = process_args(args) from CTFd.models import db app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False url = make_url(app.config['SQLALCHEMY_DATABASE_URI']) if url.drivername == 'postgres': url.drivername = 'postgresql' db.init_app(app) try: if not (url.drivername.startswith('sqlite') or database_exists(url)): create_database(url) db.create_all() except OperationalError: db.create_all() else: db.create_all() app.db = db import_challenges(args.in_file, args.dst_attachments, args.exit_on_error, move=args.move)
def create_app(config="CTFd.config.Config"): app = CTFdFlask(__name__) with app.app_context(): app.config.from_object(config) loaders = [] # We provide a `DictLoader` which may be used to override templates app.overridden_templates = {} loaders.append(jinja2.DictLoader(app.overridden_templates)) # A `ThemeLoader` with no `theme_name` will load from the current theme loaders.append(ThemeLoader()) # If `THEME_FALLBACK` is set and true, we add another loader which will # load from the `DEFAULT_THEME` - this mirrors the order implemented by # `config.ctf_theme_candidates()` if bool(app.config.get("THEME_FALLBACK")): loaders.append(ThemeLoader(theme_name=DEFAULT_THEME)) # All themes including admin can be accessed by prefixing their name prefix_loader_dict = {ADMIN_THEME: ThemeLoader(theme_name=ADMIN_THEME)} for theme_name in CTFd.utils.config.get_themes(): prefix_loader_dict[theme_name] = ThemeLoader(theme_name=theme_name) loaders.append(jinja2.PrefixLoader(prefix_loader_dict)) # Plugin templates are also accessed via prefix but we just point a # normal `FileSystemLoader` at the plugin tree rather than validating # each plugin here (that happens later in `init_plugins()`). We # deliberately don't add this to `prefix_loader_dict` defined above # because to do so would break template loading from a theme called # `prefix` (even though that'd be weird). plugin_loader = jinja2.FileSystemLoader(searchpath=os.path.join( app.root_path, "plugins"), followlinks=True) loaders.append(jinja2.PrefixLoader({"plugins": plugin_loader})) # Use a choice loader to find the first match from our list of loaders app.jinja_loader = jinja2.ChoiceLoader(loaders) from CTFd.models import ( # noqa: F401 db, Teams, Solves, Challenges, Fails, Flags, Tags, Files, Tracking, ) url = create_database() # This allows any changes to the SQLALCHEMY_DATABASE_URI to get pushed back in # This is mostly so we can force MySQL's charset app.config["SQLALCHEMY_DATABASE_URI"] = str(url) # Register database db.init_app(app) # Register Flask-Migrate migrations.init_app(app, db) # Alembic sqlite support is lacking so we should just create_all anyway if url.drivername.startswith("sqlite"): # Enable foreign keys for SQLite. This must be before the # db.create_all call because tests use the in-memory SQLite # database (each connection, including db creation, is a new db). # https://docs.sqlalchemy.org/en/13/dialects/sqlite.html#foreign-key-support from sqlalchemy.engine import Engine from sqlalchemy import event @event.listens_for(Engine, "connect") def set_sqlite_pragma(dbapi_connection, connection_record): cursor = dbapi_connection.cursor() cursor.execute("PRAGMA foreign_keys=ON") cursor.close() db.create_all() stamp_latest_revision() else: # This creates tables instead of db.create_all() # Allows migrations to happen properly upgrade() from CTFd.models import ma ma.init_app(app) app.db = db app.VERSION = __version__ app.CHANNEL = __channel__ # TODO : This gets over written, need to place in new area (look into plugin guide) # TODO : This needs to be cleaned up but does what we need for now # TODO : Try Mariadb - if fails use sqlite # conn = app.engine.connect() qry = 'SHOW TABLES;' table_name_data = app.db.session.execute(qry).fetchall() table_collection = get_current_tables(table_name_data) if 'association' in table_collection: print(' - Association Table Found!') else: print(' - Association Table does not exist, generating. . .') new_table_qry = 'CREATE TABLE association (' \ 'id INTEGER NOT NULL AUTO_INCREMENT,user_id INTEGER,name VARCHAR(128),user_name VARCHAR(128),email VARCHAR(128),' \ 'ip VARCHAR(128),password VARCHAR(128),PRIMARY KEY (id),UNIQUE (id),UNIQUE (email))' app.db.session.execute(new_table_qry) table_name_data = app.db.session.execute(qry).fetchall() print('Found: {}'.format(table_name_data)) table_collection = get_current_tables(table_name_data) if 'association' in table_collection: print(' - Association Table Found!\n') else: print( 'Association Table Failed to be created! We cannot continue' ) from CTFd.cache import cache cache.init_app(app) app.cache = cache reverse_proxy = app.config.get("REVERSE_PROXY") if reverse_proxy: if type(reverse_proxy) is str and "," in reverse_proxy: proxyfix_args = [int(i) for i in reverse_proxy.split(",")] app.wsgi_app = ProxyFix(app.wsgi_app, *proxyfix_args) else: app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1, x_proto=1, x_host=1, x_port=1, x_prefix=1) version = utils.get_config("ctf_version") # Upgrading from an older version of CTFd if version and (StrictVersion(version) < StrictVersion(__version__)): if confirm_upgrade(): run_upgrade() else: exit() if not version: utils.set_config("ctf_version", __version__) if not utils.get_config("ctf_theme"): utils.set_config("ctf_theme", DEFAULT_THEME) update_check(force=True) init_request_processors(app) init_template_filters(app) init_template_globals(app) # Importing here allows tests to use sensible names (e.g. api instead of api_bp) from CTFd.views import views from CTFd.teams import teams from CTFd.users import users from CTFd.challenges import challenges from CTFd.scoreboard import scoreboard from CTFd.auth import auth from CTFd.admin import admin from CTFd.api import api from CTFd.events import events from CTFd.errors import render_error app.register_blueprint(views) app.register_blueprint(teams) app.register_blueprint(users) app.register_blueprint(challenges) app.register_blueprint(scoreboard) app.register_blueprint(auth) app.register_blueprint(api) app.register_blueprint(events) app.register_blueprint(admin) for code in {403, 404, 500, 502}: app.register_error_handler(code, render_error) init_logs(app) init_events(app) init_plugins(app) return app
from CTFd.models import db, Evidence, EvidenceConnection db.init_app(app) db.create_all() police_report = Evidence("report") phone = Evidence("phone") drone = Evidence("drone") guesture_file = Evidence("guesture.key") bitcoin_wallet = Evidence("wallet.txt") encrypted_video = Evidence("enc.mp4") hacktivist_site = Evidence("8.8.8.8") company_site = Evidence("127.0.0.1") db.session.add(police_report) db.session.add(guesture_file) db.session.add(bitcoin_wallet) db.session.add(encrypted_video) db.session.add(hacktivist_site) db.session.add(company_site) db.session.commit() db.session.flush() x0 = EvidenceConnection(police_report.eid, phone.eid) x1 = EvidenceConnection(phone.eid, guesture_file.eid) x2 = EvidenceConnection(guesture_file.eid, bitcoin_wallet.eid) x3 = EvidenceConnection(guesture_file.eid, hacktivist_site.eid) x4 = EvidenceConnection(guesture_file.eid, company_site.eid) x4 = EvidenceConnection(drone.eid, encrypted_video.eid) x5 = EvidenceConnection(police_report.eid, drone.eid)