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)
