def solve(user, team, challenge, request): """ This method is used to insert Solves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ challenge = WriteupDynamicChallenge.query.filter_by( id=challenge.id).first() data = request.form or request.get_json() submission = data["submission"].strip() solve = Solves( user_id=user.id, team_id=team.id if team else None, challenge_id=challenge.id, ip=get_ip(req=request), provided=submission, ) db.session.add(solve) db.session.commit() WriteupDynamicValueChallenge.calculate_value(challenge)
def solve(user, team, challenge, request): """ This method is used to insert Solves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ data = request.form or request.get_json() submission = data["submission"].strip() disbot("<@" + str(user.oauth_id) + "> just solved " + str(challenge.name) + "!!") # <--- LHC DISCORD SOLVE NOTIFIER solve = Solves( user_id=user.id, team_id=team.id if team else None, challenge_id=challenge.id, ip=get_ip(req=request), provided=submission, ) db.session.add(solve) db.session.commit() db.session.close()
def solve(team, chal, request): """ This method is used to insert Solves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ teamid = Teams.query.filter_by(id=session['id']).first().id chalid = request.path.split('/')[-1] provided_key = request.form['key'].strip() db.session.expunge_all() partial = Partialsolve.query.filter_by(teamid=teamid, chalid=chalid).first() keys = json.loads(partial.flags) for key, solved in keys.iteritems(): if not solved: return db.session.expunge_all() solve = Solves(teamid=teamid, chalid=chalid, ip=utils.get_ip(req=request), flag=provided_key) db.session.add(solve) db.session.commit() db.session.close()
def solve(user, team, challenge, request): """ This method is used to insert Solves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ chal = multiChallenge.query.filter_by(id=challenge.id).first() data = request.form or request.get_json() submission = data["submission"].strip() Model = get_model() solve = Solves( user_id=user.id, team_id=team.id if team else None, challenge_id=challenge.id, ip=get_ip(req=request), provided=submission, ) db.session.add(solve) solve_count = (Solves.query.join( Model, Solves.account_id == Model.id).filter( Solves.challenge_id == challenge.id, Model.hidden == False, Model.banned == False, ).count()) db.session.commit() db.session.close()
def solve(user, team, challenge, request): """ This method is used to insert Solves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ chal = LahChallenge.query.filter_by(id=challenge.id).first() if not chal.is_unlocked: raise RuntimeError("Attempted to solve a locked lah challenge.") # check if this is the selected solve unlock = get_unlock_state() if unlock.selected == challenge.id: with db.session.no_autoflush: unlock.selected = None unlock.unlocker_id = user.id unlock.expiration = datetime.datetime.now() + datetime.timedelta(minutes = 1) scheduler.add_job(unlock_timeout_callback, DateTrigger(unlock.expiration), id=UNLOCK_TIMEOUT_JOB_ID, replace_existing=True, misfire_grace_time=999999999) db.session.commit() data = request.form or request.get_json() submission = data['submission'].strip() solve = Solves( user_id=user.id, team_id=team.id if team else None, challenge_id=challenge.id, ip=get_ip(req=request), provided=submission ) db.session.add(solve) db.session.commit() db.session.close()
def solve(team, chal, request): """ This method is used to insert Solves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ chal = FirstBloodChallenges.query.filter_by(id=chal.id).first() solve_count = Solves.query.join(Teams, Solves.teamid == Teams.id).filter( Solves.chalid == chal.id, Teams.banned == False).count() if solve_count == 0: name = 'First Blood ({})'.format(chal.name) db.session.add(Awards(team.id, name, chal.bonus)) provided_key = request.form['key'].strip() solve = Solves(teamid=team.id, chalid=chal.id, ip=utils.get_ip(req=request), flag=provided_key) db.session.add(solve) db.session.commit() db.session.close()
def edit_writeup(challenge_id: int): user = get_current_user() challenge = (db.session.query(Challenges).filter( Challenges.id == challenge_id).filter( Challenges.type != 'writeup').one_or_none()) if not challenge or not challenge.writeup_challenge: return redirect(url_for('writeups.writeups')) solves = [s.challenge_id for s in user.team.solves ] if user.team else [s.challenge_id for s in user.solves] if challenge.id not in solves: return render_template( "edit_writeup.html", challenge=challenge, error={ 'heading': '403', 'msg': 'Sorry, you must solve the challenge before submitting a write-up' }) writeup = (db.session.query(Submissions).filter( Submissions.challenge_id == challenge.writeup_challenge.id).filter( Submissions.user_id == user.id).one_or_none()) if not writeup: team_wu_solve = (db.session.query(Solves).filter( Solves.challenge_id == challenge.writeup_challenge.id).filter( Solves.team_id == user.team.id).one_or_none()) if team_wu_solve: writeup = Duplicate( challenge=challenge.writeup_challenge, user=user, team=user.team, ip=request.remote_addr, provided='', ) else: writeup = Solves( challenge=challenge.writeup_challenge, user=user, team=user.team, ip=request.remote_addr, provided='', ) db.session.add(writeup) db.session.flush() if request.method == 'POST': writeup.provided = request.form.to_dict().get('content', '') res = redirect( url_for('writeups.view_writeup', writeup_id=writeup.id)) db.session.commit() return res elif request.method == 'GET': return render_template("edit_writeup.html", challenge=challenge, writeup=writeup)
def solve(team, chal, request): """ This method is used to insert Solves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ team_id = Teams.query.filter_by(id=session['id']).first().id chal_id = request.path.split('/')[-1] try: chal_id = int(chal_id) except ValueError: return provided_key = request.form['key'].strip() db.session.expunge_all() interm_award_handler = IntermediateAwardHandler(chal_id, team_id) if not interm_award_handler.is_chal_solved(): return db.session.expunge_all() # REC FUTURE : La valeur "provided_key" n'est pas très significative. C'est le dernier flag intermédiaire obtenu pour valider le challenge. # Osef, un petit peu. Faudrait trouver le moyen de les stocker tous. solve = Solves(teamid=team_id, chalid=chal_id, ip=utils.get_ip(req=request), flag=provided_key) db.session.add(solve) db.session.commit() interm_award_handler.nullify_scores() db.session.close()
def solve(user, team, challenge, request): chal = DynICPCModel.query.filter_by(id=challenge.id).first() Model = get_model() solve = Solves(user_id=user.id, team_id=team.id if team else None, challenge_id=challenge.id, ip=get_ip(request), provided=request.judge_result['submission_id']) db.session.add(solve) solve_count = (Solves.query.join( Model, Solves.account_id == Model.id).filter( Solves.challenge_id == challenge.id, not Model.hidden, not Model.banned, ).count()) # We subtract -1 to allow the first solver to get max point value solve_count -= 1 # It is important that this calculation takes into account floats. # Hence this file uses from __future__ import division value = (((chal.minimum - chal.initial) / (chal.decay**2)) * (solve_count**2)) + chal.initial value = math.ceil(value) if value < chal.minimum: value = chal.minimum chal.value = value db.session.commit() db.session.close()
def solve(user, team, challenge, request): """ This method is used to insert Solves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ data = request.form or request.get_json() submission = data["submission"].strip() docker = DockerConfig.query.filter_by(id=1).first() try: if is_teams_mode(): docker_containers = DockerChallengeTracker.query.filter_by(docker_image=challenge.docker_image).filter_by(team_id=team.id).first() else: docker_containers = DockerChallengeTracker.query.filter_by(docker_image=challenge.docker_image).filter_by(user_id=user.id).first() delete_container(docker, docker_containers.instance_id) DockerChallengeTracker.query.filter_by(instance_id=docker_containers.instance_id).delete() except: pass solve = Solves( user_id=user.id, team_id=team.id if team else None, challenge_id=challenge.id, ip=get_ip(req=request), provided=submission, ) db.session.add(solve) db.session.commit() db.session.close()
def solve(team, chal, request): """ This method is used to insert Solves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ chal = CommunityChallengeModel.query.filter_by(id=chal.id).first() solve_count = Solves.query.join(Teams, Solves.teamid == Teams.id).filter( Solves.chalid == chal.id, Teams.banned == False).count() # if this is the first validation, we give the bonus points to the chal's owner if solve_count == 0: award = Awards( teamid=chal.owner, name=text_type( 'Bonus points for submitting challenge {}'.format( chal.name)), value=chal.value) db.session.add(award) provided_key = request.form['key'].strip() solve = Solves(teamid=team.id, chalid=chal.id, ip=utils.get_ip(req=request), flag=provided_key) db.session.add(solve) db.session.commit() db.session.close()
def patch(self, submission_id): submission = Submissions.query.filter_by( id=submission_id).first_or_404() challenges = Challenges.query.filter_by( id=submission.challenge_id).first_or_404() #challenges.value = challenges.value - 1 #Need to award points awards = Awards( user_id=submission.user_id, team_id=submission.team_id, description=submission.provided, value=1, category=submission.challenge_id, ) submission.type = 'correct' log('submission', "[{date}] {name} submitted {submission} with TYPE {kpm}, Challeng ID {tpm} ", submission=submission.id, kpm=submission.type, tpm=submission.challenge_id) solve = Solves(user_id=submission.user_id, team_id=submission.team_id, challenge_id=submission.challenge_id, ip=submission.ip, provided=submission.provided) db.session.add(awards) db.session.add(solve) db.session.delete(submission) db.session.commit() db.session.close() return { 'success': True, }
def solve(team, chal, request): """ This method is used to insert Solves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ chal = DynamicChallenge.query.filter_by(id=chal.id).first() solve_count = Solves.query.join(Teams, Solves.teamid == Teams.id).filter( Solves.chalid == chal.id, Teams.banned == False).count() value = (((chal.minimum - chal.initial) / (chal.decay**2)) * (solve_count**2)) + chal.initial value = math.ceil(value) if value < chal.minimum: value = chal.minimum chal.value = value provided_key = request.form['key'].strip() solve = Solves(teamid=team.id, chalid=chal.id, ip=utils.get_ip(req=request), flag=provided_key) db.session.add(solve) db.session.commit() db.session.close()
def gen_solve(db, user_id, team_id=None, challenge_id=None, ip="127.0.0.1", provided="rightkey", **kwargs): solve = Solves(user_id=user_id, team_id=team_id, challenge_id=challenge_id, ip=ip, provided=provided, **kwargs) solve.date = datetime.datetime.utcnow() db.session.add(solve) db.session.commit() return solve
def create_solve(teamid, chalid): solve = Solves(chalid=chalid, teamid=teamid, ip='127.0.0.1', flag='MARKED_AS_SOLVED_BY_ADMIN') db.session.add(solve) db.session.commit() db.session.close() return '1'
def solve(team, chal, request): provided_key = request.form['key'].strip() solve = Solves(teamid=team.id, chalid=chal.id, ip=utils.get_ip(req=request), flag=provided_key) db.session.add(solve) db.session.commit() db.session.close()
def solve(team, chal, request): chal = GenFlagCDBM.query.filter_by(id=chal.id).first() solve_count = Solves.query.join(Teams, Solves.teamid == Teams.id).filter(Solves.chalid==chal.id, Teams.banned==False).count() provided_key = request.form['key'].strip() solve = Solves(teamid=team.id, chalid=chal.id, ip=utils.get_ip(req=request), flag=provided_key) db.session.add(solve) db.session.commit() db.session.close()
def solve(user, team, challenge, request): """ This method is used to insert Solves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ chal = DynamicChallenge.query.filter_by(id=challenge.id).first() data = request.form or request.get_json() submission = data['submission'].strip() Model = get_model() solve_count = Solves.query \ .join(Model, Solves.account_id == Model.id) \ .filter(Solves.challenge_id == challenge.id, Model.hidden == False, Model.banned == False) \ .count() # It is important that this calculation takes into account floats. # Hence this file uses from __future__ import division # value = ( # ( # (chal.minimum - chal.initial) / (chal.decay**2) # ) * (solve_count**2) # ) + chal.initial if (team and team.hidden == True) or (not team and user.hidden == True): pass else: value = chal.initial * 0.03 + ( (chal.initial * 0.97) / (1 + (max(0, solve_count) / 4.92201)**3.206069)) value = math.ceil(value) if value < chal.minimum: value = chal.minimum if chal.decay != 0 and solve_count >= chal.decay: value = chal.minimum chal.value = value solve = Solves(user_id=user.id, team_id=team.id if team else None, challenge_id=challenge.id, ip=get_ip(req=request), provided=submission) db.session.add(solve) db.session.commit() db.session.close()
def solve(user, team, challenge, request): """ This method is used to insert Solves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ challenge = GuessPenaltyChallenge.query.filter_by( id=challenge.id).first() data = request.form or request.get_json() submission = data["submission"].strip() Model = get_model() solve = Solves( user_id=user.id, team_id=team.id if team else None, challenge_id=challenge.id, ip=get_ip(req=request), provided=submission, ) # Issue penalty award fail_count = (Fails.query.join(Model, Fails.account_id == Model.id).filter( Fails.challenge_id == challenge.id, Model.hidden == False, Model.banned == False, ).count()) value = (((challenge.minimum - challenge.initial) / (challenge.decay**2)) * (fail_count**2)) + challenge.initial value = math.ceil(value) if value < challenge.minimum: value = challenge.minimum value = value - challenge.initial penalty = Awards(user_id=user.id, team_id=team.id if team else None, name="FAIL Penalty: %s" % challenge.name, description="Penalty for incorrect attempts", value=value, category=challenge.category, icon="") # Commit to database db.session.add(solve) db.session.add(penalty) db.session.commit()
def solve(user, team, challenge, request): """ This method is used to insert Solves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ chal = AliyunChallenge.query.filter_by(id=challenge.id).first() data = request.form or request.get_json() submission = data["submission"].strip() Model = get_model() solve = Solves( user_id=user.id, team_id=team.id if team else None, challenge_id=challenge.id, ip=get_ip(req=request), provided=submission, ) db.session.add(solve) solve_count = ( Solves.query.join(Model, Solves.account_id == Model.id) .filter( Solves.challenge_id == challenge.id, Model.hidden == False, Model.banned == False, ) .count() ) # We subtract -1 to allow the first solver to get max point value solve_count -= 1 # It is important that this calculation takes into account floats. # Hence this file uses from __future__ import division value = ( ((chal.minimum - chal.initial) / (chal.decay ** 2)) * (solve_count ** 2) ) + chal.initial value = math.ceil(value) if value < chal.minimum: value = chal.minimum chal.value = value db.session.commit() db.session.close()
def solve(team, chal, request): """ This method is used to insert Solves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ provided_key = request.form['key'].strip() solve = Solves(teamid=team.id, chalid=chal.id, ip=utils.get_ip(req=request), flag=provided_key) db.session.add(solve) db.session.commit() db.session.close()
def solve(cls, user, team, challenge, request): data = request.form or request.get_json() provided = ",".join( map(lambda x: x.split("_")[-1].upper(), filter(lambda x: data[x] is True, data))) solve = Solves( user_id=user.id, team_id=team.id if team else None, challenge_id=challenge.id, ip=get_ip(req=request), provided=provided, ) db.session.add(solve) db.session.commit()
def solve(user, team, challenge, request): """ This method is used to insert Solves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ data = request.form or request.get_json() submission = data['submission'].strip() solve = Solves(user_id=user.id, team_id=team.id if team else None, challenge_id=challenge.id, ip=get_ip(req=request), provided=submission)
def solve(team, chal, request): """ This method is used to insert TimeDecaySolves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ provided_key = request.form['key'].strip() # Record current value for the challenge value = TimeDecayChallenge.value(chal) solve = Solves(teamid=team.id, chalid=chal.id, ip=utils.get_ip(req=request), flag=provided_key) db.session.add(solve) time_decay_solve = TimeDecaySolves(teamid=team.id, chalid=chal.id, decayed_value=value) db.session.add(time_decay_solve) db.session.commit() db.session.close()
def solve(user, team, challenge, request): """ This method is used to insert Solves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ chal = DynamicChallenge.query.filter_by(id=challenge.id).first() data = request.form or request.get_json() submission = data['submission'].strip() solve_count = Solves.query\ .join(Teams, Solves.team_id == Teams.id)\ .filter(Solves.challenge_id == chal.id, Teams.banned == False)\ .count() # It is important that this calculation takes into account floats. # Hence this file uses from __future__ import division value = ( ( (chal.minimum - chal.initial) / (chal.decay**2) ) * (solve_count**2) ) + chal.initial value = math.ceil(value) if value < chal.minimum: value = chal.minimum chal.value = value solve = Solves( user_id=user.id, team_id=team.id if team else None, challenge_id=challenge.id, ip=get_ip(req=request), provided=submission ) db.session.add(solve) db.session.commit() db.session.close()
def solve(user, team, challenge, request): """ This method is used to insert Solves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ data = request.form or request.get_json() submission = "No flags for this challenge" solve = Solves( user_id=user.id, team_id=team.id if team else None, challenge_id=challenge.id, ip=get_ip(req=request), provided=submission, ) db.session.add(solve) db.session.commit() db.session.close()
def solve(user, team, challenge, request): chal = KeyedChallenge.query.filter_by(id=challenge.id).first() data = request.form or request.get_json() submission = data['submission'].strip() Model = get_model() solve_count = Solves.query \ .join(Model, Solves.account_id == Model.id) \ .filter(Solves.challenge_id == challenge.id, Model.hidden == False, Model.banned == False) \ .count() solve = Solves(user_id=user.id, team_id=team.id if team else None, challenge_id=challenge.id, ip=get_ip(req=request), provided=submission) db.session.add(solve) db.session.commit() db.session.close()
def manual_approve(id): submission = Pending.query.filter_by(id=id).first() submission.type = 'correct' solve = Solves( user_id=submission.user_id, team_id=submission.team_id if submission.team_id else None, challenge_id=submission.challenge_id, ip=submission.ip, provided=submission.provided, ) db.session.add(solve) db.session.delete(submission) db.session.commit() db.session.close() return redirect(url_for('.manual_list_to_grade'))
def solve(team, chal, request): """ This method is used to insert Solves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ bonus = BonusChallenges.query.filter_by(id=chal.id).first() account_id = team.id provided_key = request.form['key'].strip() # solve = Solves(team_id=account_id, user_id=account_id, challenge_id=chal.id, ip=user.get_ip(req=request), flag=provided_key) try: solve = Solves(team_id=account_id, user_id=account_id, challenge_id=chal.id, ip=user.get_ip(req=request)) db.session.add(solve) db.session.commit() # db.session.close() # don't close too soon. There is a parent query above this in /bonus route handler; ctrl-f for 'bhk3' except: db.session.rollback()
def solve(user, team, challenge, request): """ This method is used to insert Solves into the database in order to mark a challenge as solved. :param team: The Team object from the database :param chal: The Challenge object from the database :param request: The request the user submitted :return: """ chal = IntegratedChallenge.query.filter_by(id=challenge.id).first() data = request.form or request.get_json() submission = data['submission'].strip() Model = get_model() solve = Solves(user_id=user.id, team_id=team.id if team else None, challenge_id=challenge.id, ip=get_ip(req=request), provided=submission) db.session.add(solve) db.session.commit() db.session.close()
team = Teams(name, name.lower() + gen_email(), "password") team.verified = True db.session.add(team) count += 1 db.session.commit() ### Generating Solves print("GENERATING SOLVES") for x in range(USER_AMOUNT): used = [] base_time = datetime.datetime.utcnow() + datetime.timedelta(minutes=-10000) for y in range(random.randint(1, CHAL_AMOUNT)): chalid = random.randint(1, CHAL_AMOUNT) if chalid not in used: used.append(chalid) solve = Solves(chalid, x + 1, "127.0.0.1", gen_word()) new_base = random_date(base_time, base_time + datetime.timedelta(minutes=random.randint(30, 60))) solve.date = new_base base_time = new_base db.session.add(solve) db.session.commit() ### Generating Wrong Keys print("GENERATING WRONG KEYS") for x in range(USER_AMOUNT): used = [] base_time = datetime.datetime.utcnow() + datetime.timedelta(minutes=-10000) for y in range(random.randint(1, CHAL_AMOUNT * 20)): chalid = random.randint(1, CHAL_AMOUNT)