def new_post():
if request.method == "POST":
mar = request.form.get("markdown") # 编辑元吗
html = request.form.get("html") # HTML 源码
title = request.form.get("title") # 标题
tag = request.form.get("tag") # 标签
tag_list = tag.split('，')
user_id = session['user']
# user_id = int(user)
# 存储 标题信息
sql = "INSERT INTO posts(`url`, `title`, `content_text`, `content_html`,user_id) VALUES \
('%s','%s','%s','%s','%d')" % (title, title, mar, html, user_id)
db.update_db(sql)
# 存储标签内容
title_selectsql = "SELECT * FROM posts WHERE title='" + title + "'"
rows = db.query_db(title_selectsql, one=True)
for i in tag_list:
post_tag_sql = "INSERT INTO posts_tags(post_id,tag_name) value('%d','%s')" % (
rows[0], i)
db.update_db(post_tag_sql)
return mar + "---" + html + "---" + title + "---" + str(
tag_list) + 'l:' + str(rows[0])
# return "错误了"
return render_template('new.html')
def clear_board(cls):
def end():
# if any letters present at the top
if any(tm.Tetromino.board_matrix[0]):
return True
# If all elements in board_matrix's row are != 0, clear them
update = [tm.Tetromino.board_matrix[i] for i in range(cls.BoardHeight) \
if not all(tm.Tetromino.board_matrix[i])]
before_clean = len(tm.Tetromino.board_matrix)
after_clean = len(update)
clear_amount = before_clean - after_clean
cls.score += cls.scoring[clear_amount]
for _ in range(clear_amount):
update[:0] = [[0 for _ in range(cls.BoardWidth)]]
tm.Tetromino.board_matrix = update
if end() and not cls.end:
cls.end = True
db.update_db(cls.score)
cls.run = False
def rerun(job_id):
"""
Schedules again a job with AWS. To be used when it had been started
but its instance was terminated before the job completed.
The local database is also updated with the new status and schedule
data (that is now + 1 minute).
Args:
job_id: The job id.
"""
# Get all the necessary data to schedule a new spot instance
# (container image, env vars)
[docker_image, env_vars] = db.job_db_data(db_conn, job_id,
"docker_image", "env_vars")
# Re-schedule the spot instance to run 1 minute from now
stime = datetime.now()+timedelta(minutes=1)
[req_id, req_state, req_status_code] = \
aws.create_spot_instance(config["aws"], job_id, stime,
docker_image, env_vars)
# Updates the database with the new status and scheduled time
db.update_db(db_conn, job_id, req_id=req_id, req_state=req_state, \
req_status_code=req_status_code, status="%s" % \
STATUS_RE_SCHEDULED, instance_id="", run_at=stime)
def poc_scan(request):
#hook result
global list_report
list_report = []
if request.GET:
#获取检测的id和url
vul_id = request.GET['id']
url = request.GET['url']
session = request.user.username
#获取id 对应的文件名
poc = poc_list.objects.get(vulID=vul_id) #poc.filename
file = open(os.path.join(BASE_DIR, poc.filename))
info = {'pocstring': file.read(), 'pocname': poc.filename}
file.close()
cn = TestApi(url, info)
#保存扫描记录
scan_in_db(session, url)
try:
result = cn.run()
#print result
if result[5][1] == "success":
#print "is vul"
#print result[7]
#增加漏洞风险等级字段
#result = result + (poc.cvss,)
#list_report.append(result)
#print list_report
#增加pocsuitejson报告文件名缺少.问题 1-redis-getshell.py , 1-redis-getshellpy
str_list = list(result) #元组转换列表
# print type(str_list)
pocname_str_list = list(str_list[1].encode("utf-8"))
pocname_str_list.insert(-2, '.')
# print pocname_str_list
pocname_str_list = "".join(pocname_str_list).decode("utf-8")
str_list[1] = pocname_str_list
str_list[5] = 'success'
result = tuple(str_list)
result = result + (poc.cvss, )
print result
list_report.append(result)
print list_report
#存数据库
vul_in_db(session, list_report)
#发送邮件
return HttpResponse(1) #True
else:
#print "not vul"
#去数据库查询，若曾经有漏洞则更新漏洞状态
update_db(url, vul_id)
return HttpResponse(0) #False
#send_mail(request,list_report)
except Exception, e:
print e
#traceback.print_exc()
return HttpResponse(0) #False
async def have_drink(ctx, drink):
data = open_db("database/passports.json")
items = open_db("database/items.json")
drinks = items["drinks"]
user_name = str(ctx.author)
inventory = data[user_name]["items"]
if drink in drinks and drink in inventory:
inventory.remove(drink)
update_db("database/passports.json", data)
await ctx.send(ctx.author.name + ' выпил ' + drink)
return
await ctx.send("У вас нет такого предмета или его нельзя пить")
def process_notification(job_id):
"""
Handles the PUT /v1/notifications/<job-id>?status=xxx request.
This enpoint is used by the spot instances to notify about some
important event (notably the container has started or finished).
The database is updated so that future GET /v1/jobs/<job-id> requests
get the latest information.
If a "finished" status has been sent, the user defined callback endpoint
(if any) for that job is called and the spot instance is terminated. In
addition, a note is stored in the "notes" column stating if
the callback ran ok or not.
"""
# Get the status sent
status = request.args.get('status')
if status == None:
return make_response(jsonify({'Error': \
'Missing status= parameter'}), 400)
# Try to update the DB with the status
try:
db.update_db(db_conn, job_id, status=status)
# If status is "finished', then execute the user defined callback
# for this job and terminate the spot instance.
if status == "finished":
logging.info("Executing job %s user callback function: %s", \
job_id, callback_function(job_id))
call_callback(job_id)
instance_id = db.job_db_data(db_conn, job_id, "instance_id")
logging.info("Terminating job %s spot instance %s", \
job_id, instance_id)
aws.terminate_instance(instance_id)
logging.info("Marking job %s as done", job_id)
db.update_db(db_conn, job_id, status='%s' % STATUS_DONE)
return make_response(jsonify({'Success': \
'Notification has been processed, status updated to %s' % \
status}), 200)
except Exception as e:
return make_response(jsonify({'Error': \
'Something went wrong when updating DB - %s' % str(e)}), 500)
async def passport(ctx):
data = open_db("database/passports.json")
user = str(ctx.author)
if user in data:
money = data[user]["coin"]
items = ''
for item in data[user]["items"]:
items = items + '```py\n@ ' + item + '\n' + '```'
items = items if items != '' else '```py\n @ пусто```'
await ctx.send('**Инвентарь ' + ctx.author.name + ':**\n' + items +
'\nДеньги: ' + str(money) + ':pizza:')
else:
data[user] = {'coin': 0, 'item': [], 'work': False}
update_db("database/passports.json", data)
await ctx.send(ctx.author.name + ' Получил паспорт')
async def drink_accept(ctx):
user = str(ctx.author)
data = open_db("database/passports.json")
salary = 10
if not data[user]["work"]:
data[user]["work"] = True
update_db("database/passports.json", data)
await ctx.send(ctx.author.name + ' начал работать')
await asyncio.sleep(5)
data[user]["coin"] += salary
await ctx.send(ctx.author.name + ' заработал ' + str(salary))
data[user]["work"] = False
update_db("database/passports.json", data)
else:
await ctx.send(ctx.author.name + ', ты уже работаешь')
def check_jobs():
"""
This function is called by apscheduler every 60s (configurable via
"APP_POLLING_INTERVAL" environment variable).
For each job that is ready to run and still needs to be processed
(status is not 'done'), this function polls AWS to get
the latest information about the corresponding spot instance request
(its state, status code and instance_id, if any) and updates the local
database.
If the request state is marked as closed (and not due to an application
ask), this means the spot instance was interrupted for some reason. In
this case, a new spot instance is scheduled to be run one minute
from now.
"""
# Get all jobs that are ready to be processed (scheduled
# for a time in the past and has not been finished yet)
cursor = db_conn.cursor(MySQLdb.cursors.DictCursor)
cursor.execute("SELECT * FROM jobs WHERE run_at <= NOW() AND " \
"status <> '%s' AND (req_state='active' OR " \
"req_state='open')" % STATUS_DONE)
rows = cursor.fetchall()
# For each job
for row in rows:
logging.info("Polling job %s status with AWS", row['id'])
logging.debug("DB row: %s", row)
# Asks AWS about the latest information about the job
# spot instance request and save into the local database
# If the instance was running and has been terminated, run
# it again.
job_id = row['id']
[aws_req_state, aws_req_status_code, aws_instance_id] = \
aws.get_aws_req_status(row['req_id'])
if aws_req_state == 'open':
db.update_db(db_conn, job_id, req_state=aws_req_state,
req_status_code=aws_req_status_code)
elif aws_req_state != 'closed':
db.update_db(db_conn, job_id, req_state=aws_req_state,
req_status_code=aws_req_status_code,
instance_id=aws_instance_id)
elif aws_req_state == 'closed':
rerun(job_id)
def update_posts():
logger.info('UPDATE POSTS')
groups = db.get_all_group()
r = True
for g in groups:
ext, l_ret = read_vk_content(g.url)
r &= db.update_db(g, l_ret)
r &= db.update_description_group(g, ext)
return r
def update_job(job_id):
"""
Handles the PUT /v1/jobs/<job-id> request (where a specific job
must be updated). Currently, only callback is supported.
job status).
A JSON must be sent along with the request specifying the new
callback to be used.
"""
# Make sure a well formed json was posted
try:
json = request.get_json()
except:
return jsonify({"Error": \
"Bad request. Make sure that the JSON posted is well formed."}), 400
# Job exists and it's still time to change? (it's not already
# running or it's done?)
cursor = db_conn.cursor()
cursor.execute("SELECT * FROM jobs WHERE id = %s AND status='%s'" \
%(job_id, STATUS_SCHEDULED))
if cursor.rowcount == 0:
return make_response(jsonify({'error': \
'No job with such id was found or the job is already ' \
'running or done'}), 404)
# Make sure the JSON contains a callback field
elif not json.has_key("callback"):
return make_response(jsonify({'error': \
'No callback was specified.'}), 400)
# Try to update the database with the new callback endpoint
try:
db.update_db(db_conn, job_id, callback=json["callback"])
return make_response(jsonify({'Success': \
'Callback function updated to %s' % json["callback"]}), 200)
except Exception as e:
return make_response(
jsonify({'Error': \
'Something went wrong when updating DB - %s' % str(e)}), 500)
async def drink_accept(ctx, user: discord.Member):
data = open_db("database/passports.json")
data_bar = open_db("database/bar.json")
items = open_db("database/items.json")
client = str(user)
if client in data_bar["order"]:
order = data_bar["order"][client]
if data[client]["coin"] >= items["drinks"][str(order)]["cost"]:
print(order)
data[client]["coin"] -= items["drinks"][str(order)]["cost"]
data[client]["items"].append(str(order))
data[str(
ctx.author)]["coin"] += items["drinks"][str(order)]["cost"]
update_db('database/passports.json', data)
order2 = data_bar["order"].pop(client)
update_db('database/bar.json', data_bar)
await ctx.send('Заказ ' + client + 'оформлен(' + str(order2) + ')')
else:
await ctx.send('У ' + client + ' не достаточно средств')
else:
await ctx.send('Пользователь ничего не заказывал (Стёпа - дэбил)')
async def drink_order(ctx, drink):
data = open_db("database/passports.json")
data_bar = open_db("database/bar.json")
items = open_db("database/items.json")
drinks = items["drinks"]
user_name = str(ctx.author)
user = data[user_name]
if drink in drinks:
if user["coin"] >= drinks[drink]["cost"]:
order = data_bar["order"]
if user_name not in data_bar["order"]:
order[user_name] = ''
order[user_name] = drink
update_db("database/bar.json", data_bar)
await ctx.send(ctx.author.name + ' заказал ' + drink)
return
menu = ''
for drink_menu in drinks:
drink_menu_str = str(drink_menu)
menu = menu + drink_menu_str + ': ' + str(
drinks[drink_menu_str]["cost"]) + ':pizza:' + '\n'
await ctx.send(ctx.author.name + ': \n' + menu)
def api_main(access_token_json):
""" Takes the JSON file returned from the Instagram OAuth and updates the
database with that data and returns the username of the user so other
functions can call that in the future.
"""
username, access_token = get_token_and_username(access_token_json)
insta_json_data = call_instagram_api(access_token)
list_img = []
if not check_user(username):
list_img = get_list_of_img_id(username)
user_info = read_insta_json(insta_json_data, list_img)
#Iterate through all of the lists in user info
for i in user_info:
image_url = i[0]
image_id = i[1]
download_image(image_url, image_id)
labels, is_spoof, is_racy, landmark, has_text, has_face, emotion = analyze_file(
'app/static/img/' + image_id + '.jpg')
google_image_output = [
labels, is_spoof, is_racy, landmark, has_text, has_face, emotion
]
i.append(google_image_output)
# Get the information from the database using the output_db function.
# The return values from this would only be the newly updated images that
# didn't already exist on the database beforehand.
update_db(username, user_info)
return username
def dataReceived(self, data):
"""
As soon as any data is received, write it back.
"""
packets = filter(None, data.split("%"))
packets = [json.loads(packet) for packet in packets]
for packet in packets:
if packet["_header"] == "CLIENT":
self._client = packet["_payload"]
elif packet["_header"] == "JSON":
self._buffer = self._buffer + packet["_payload"].rstrip()
if self._buffer.endswith('}'):
friends = json.loads(self._buffer)
friends_u = update_db(friends, self._client)
friendsLine = json.dumps(friends_u)
packets = Packet.pack("JSON", friendsLine)
for packet in packets:
data = json.dumps(packet.__dict__)
self.transport.write(data + "%")
self._buffer = ""
def call_callback(job_id):
"""
Calls the user define callback endpoint for the specified job.
The notes job column is updated with the success/error message.
Args:
job_id: the job id.
"""
# Get the callback endpoint fot the job
url = callback_function(job_id)
try:
# Try to call it
f = urllib2.urlopen(url)
f.close()
except URLError as e:
logging.info("Error when calling back job %s callback function(%s)", \
job_id, url)
db.update_db(db_conn, job_id, notes="Tried to callback %s but" \
" seems like an invalid url: %s" %(url, e.reason))
except Exception as e:
db.update_db(db_conn, job_id, notes="Something went wrong when" \
" trying to callback %s: %s" %(url, e.message))
else:
logging.info("Job %s callback function(%s) called " \
"successfully", job_id, url)
db.update_db(db_conn, job_id,
notes="Called back %s sucessfully at %s" %
(url, datetime.now()))
def course_results():
initial_data = []
for i in range(num_of_course_t):
course_temp_t = request.form.get("course_t " + str(i + 1))
class_code_temp_t = request.form.get("class_t " + str(i + 1))
term_temp_t = request.form.get("term_t " + str(i + 1))
instructor_temp_t = request.form.get("instructor_t " + str(i + 1))
time_temp_t = request.form.get("time_t " + str(i + 1))
course_nature_temp_t = request.form.get("course_nature_t " +
str(i + 1))
initial_data_temp = {
'course': course_temp_t,
'class_code': class_code_temp_t,
'term': term_temp_t,
'instructor': instructor_temp_t,
'timeslot': time_temp_t,
'course_nature': course_nature_temp_t
}
initial_data.append(initial_data_temp)
exist_result = get_exist_course_db(initial_data)
all_data = get_admin_db()
# find exist data, temp update (replace exist_data by initial_data), temp insert (insert initial_data to all_data), check temp conflicts
if all_data != []:
for in_data in initial_data:
for a in range(len(all_data)):
if all_data[a]['course'] == in_data['course'] and all_data[a][
'class_code'] == in_data['class_code'] and all_data[a][
'term'] == in_data['term']:
all_data[a] = in_data
match = 0
break
else:
match = 1
if match == 0:
continue
elif match == 1:
all_data.append(in_data)
else:
all_data = initial_data
conflict_list_temp = check_course_conflicts(all_data)
if conflict_list_temp == []:
if len(exist_result) > 0:
insert_data = []
update_data = []
for i_data in initial_data:
for e_data in exist_result:
if i_data['course'] == e_data['course'] and i_data[
'class_code'] == e_data['class_code'] and i_data[
'term'] == e_data['term']:
update_data.append(i_data)
else:
insert_data.append(i_data)
update_db(update_data)
insert_db(insert_data)
run_template = render_template("success_bs.html",
update_courses=initial_data)
elif len(exist_result) == 0:
insert_db(initial_data)
run_template = render_template("success_bs.html",
update_courses=initial_data)
else:
run_template = render_template("course_conflicts_bs.html",
conflicts_list=conflict_list_temp)
return run_template
def __init__(self):
# Stores the checked out equipment to a given username in the form:
# {user: [timestamp, bldg, items]}
db.update_db()
self._state_file = os.path.join(*'resources state.pickle'.split())
self.transactions = self._load_transactions()
def __init__(self):
# Stores the checked out equipment to a given username in the form:
# {user: [timestamp, bldg, items]}
db.update_db()
self._state_file = os.path.join(*'resources state.pickle'.split())
self.transactions = self._load_transactions()
def update_status_by_link(link):
sql = "update link set status=0,modify_time='%s' where link='%s'" % (
datetime.now().strftime("%Y-%m-%d %H:%M:%S"), link)
update_db(sql)
def rescan_all(request):
if request.method == "GET":
output = []
username = request.user.username
vul_list = models.vul_scan.objects.values('url').filter(username=username).distinct()
# print vul_list
for d_url in vul_list:
# print d_url
url = d_url['url']
# print url
r_list = models.vul_state.objects.all().filter(url=url).filter(state=u'未修复')
# print r_list
for i in r_list:
vulname = i.vulname
vulid = models.poc_list.objects.get(name=vulname).vulID
cvss = i.cvss
pocname = models.poc_list.objects.get(name=vulname).filename
output.append([url, pocname, cvss, vulid])
# print output
for i in output:
file = open(os.path.join(BASE_DIR, i[1]))
info = {'pocstring': file.read(),
'pocname': i[1]
}
file.close()
cn = TestApi(i[0], info)
try:
list_report = []
result = cn.run()
# print result
if result[5][1] == "success":
# print "is vul"
# print result[7]
# 增加漏洞风险等级字段
str_list = list(result) # 元组转换列表
# print type(str_list)
pocname_str_list = list(str_list[1].encode("utf-8"))
pocname_str_list.insert(-2, '.')
# print pocname_str_list
pocname_str_list = "".join(pocname_str_list).decode("utf-8")
str_list[1] = pocname_str_list
str_list[5] = 'success'
result = tuple(str_list)
result = result + (i[2],)
# print result
list_report.append(result)
print list_report
# 存数据库
vul_in_db(username, list_report)
else:
# print "not vul"
# 去数据库查询，若曾经有漏洞则更新漏洞状态
update_db(url, i[3])
except Exception, e:
print e
return HttpResponse(0) # False
return HttpResponse(1)
def update_status_by_id(id):
sql = "update id set status=0,modify_time='%s' where id='%s'" % (
datetime.now().strftime("%Y-%m-%d %H:%M:%S"), id)
update_db(sql)
def update_count_by_link(link):
sql = "update link set get_count=get_count+1 where link='%s'" % (link)
update_db(sql)
def schedule_job():
"""
This function handles the POST /v1/jobs request (a new job must
be created and scheduled).
It reads the JSON sent, makes sure it's well formed, parse its
data and store it on a database.
A 400 code can be returned if the JSON is not well formed, the
specified schedule date/time is not in the future or if there's
any mandatory field missing.
This is an example JSON:
{
"docker_image": "xx",
"date_time": "YYYY-MM-DD HH:MM:SS",
"callback": "http://mycallback.com?xx",
"env-variables": {
"env1": "e1",
"env2": "e2"
}
}
date_time must be specified in the UTC timezone. env-variables and
callback parameters are optional.
If everything is OK, a 201 is returned with a JSON confirming the
job data and with its job-id.
"""
# Make sure a well formed json was posted
try:
json = request.get_json()
except:
return jsonify({"Error": "Bad request. Make sure that the JSON " \
"posted is well formed."}), 400
# Return an error if there is any mandatory field missing
if not(json.has_key("docker_image") and json.has_key("datetime")):
return jsonify({"Error": "docker_image or datetime is missing"}), 400
# Verify if time format is ok and stores in into a time-tuple format
try:
stime = datetime.strptime(json["datetime"], "%Y-%m-%d %H:%M:%S")
except ValueError:
return jsonify({"Error": "Date format must be yyyy-mm-dd hh:mm:ss"}), \
400
# Ensure time is in the future
if stime < datetime.now():
return jsonify({"Error": "Date/time must be in the future"}), 400
# Get callback if it was sent
callback = json.get("callback", "")
# Get the env_vars is it was sent
env_vars = None
if json.has_key("env_vars"):
if type(json["env_vars"]) is dict:
env_vars = json["env_vars"]
# Convert the env vars to a notation format to be accepted
# by docker("-e 'X1=v1' -e 'X2=v2' etc)
env_vars = build_env_vars_docker_format(env_vars)
# Save the job in the database and get its unique job id
job_id = save_job_schedule(db_conn, json["docker_image"], stime,
callback, env_vars)
if job_id == -1:
return make_response(
jsonify({'error': 'Something went wrong when attempting ' \
'to save data into db'}), 500)
# Schedule the spot instance with AWS and update the db
# with the parameters gotten.
[req_id, req_state, req_status_code] = \
aws.create_spot_instance(config["aws"], job_id, stime,
json["docker_image"], env_vars)
db.update_db(db_conn, job_id, req_id=req_id, req_state=req_state,
req_status_code=req_status_code)
# Returns a json with the accepted json data and the job-id appended
json["job_id"] = job_id
return jsonify(json), 201
