def getSelectStudentNum(courseId):
conn = Connection.getConnection()
cursor = conn.cursor()
sql = "select count(*) from selection where course_id = %d" % (
courseId)
cursor.execute(sql)
return cursor.fetchone()[0]
def getCourseInfo(student_id): conn = Connection.getConnection() cursor = conn.cursor() sql = "select * from course where course_id in \ (select course_id from selection where student_id = %d)"%(student_id) cursor.execute(sql) return cursor.fetchall()
async def startup(setup_mode, force_local_mode, config_file, first_psbt):
# All startup/operation code
loop = asyncio.get_running_loop()
if loop.get_debug():
# quiet noise about slow stuff
loop.slow_callback_duration = 10
from utils import setup_logging
setup_logging()
from persist import Settings
Settings.startup(config_file)
aws = []
# copy some args into status area
from status import STATUS
STATUS.force_local_mode = force_local_mode
STATUS.setup_mode = setup_mode
# preload the contents of a PSBT
if first_psbt:
STATUS.import_psbt(first_psbt)
from torsion import TOR
aws.append(TOR.startup())
from conn import Connection
aws.append(Connection(force_serial).run())
import webapp
aws.append(webapp.startup(setup_mode))
await asyncio.gather(*aws)
def getSelectCourseNum(studentId):
conn = Connection.getConnection()
cursor = conn.cursor()
sql = "select count(*) from selection where student_id = %d" % (
studentId)
cursor.execute(sql)
result = cursor.fetchone()
return result[0]
async def setup_page(request):
# HSM policy setup
# get latest status
dev = Connection()
await dev.hsm_status()
return await add_shared_ctx(request)
def getStudentIdByUserName(username):
conn = Connection.getConnection()
cursor = conn.cursor()
sql = "select student_id from student_account where username = '******'" % (
username)
cursor.execute(sql)
return cursor.fetchone()[0]
def isAccountValid(username, password):
connection = Connection.getConnection()
cursor = connection.cursor()
sql = "select * from student_account where username = '******' and password = '******'" % (
username, password)
cursor.execute(sql)
resultList = cursor.fetchall()
return len(resultList) == 1
async def bunker_page(request):
# Bunker config and setup
# get latest status
dev = Connection()
await dev.hsm_status()
from torsion import TOR
return await add_shared_ctx(request, BP=BP, force_local_mode=STATUS.force_local_mode)
def selectCourse(student_id, course_id):
conn = Connection.getConnection()
cursor = conn.cursor()
sql = "select * from selection \
where student_id=%d and course_id=%d"%(student_id, course_id)
cursor.execute(sql)
if (len(cursor.fetchall()) == 0):
sql = "insert into selection values(%d, %d)"%(student_id, course_id)
cursor.execute(sql)
conn.commit()
return ('1', u"成功选择该课程")
else:
return ('0', u"已经选过该课程")
def quitCourse(student_id, course_id):
conn = Connection.getConnection()
cursor = conn.cursor()
sql = "select * from selection \
where student_id=%d and course_id=%d"%(student_id, course_id)
cursor.execute(sql)
if (len(cursor.fetchall()) > 0):
sql = "delete from selection \
where student_id=%d and course_id=%d"%(student_id, course_id)
cursor.execute(sql)
conn.commit()
return ('1', u"成功退选该课程")
else:
return ('0', u"没有选择该课程")
def server():
"""Server listening on named pipes and serving forever."""
downlink = Connection('downlink', 'w+')
uplink = Connection('uplink', 'r')
cur_phase = 'INIT'
ffs_counter = [0]
# Listen for messages
for request in uplink.receive():
logger.debug('IN\t ' + request)
response, cur_phase = serve_request(request, cur_phase, ffs_counter)
if not response:
continue
downlink.send(response)
logger.debug('OUT\t ' + response)
downlink.close()
uplink.close()
class Interns:
def __init__(self):
# connect to database
self.connection = Connection()
self.connection.connect_database()
def exists(self, user_id):
# get user_id exists or not
query = "SELECT user_id FROM interns WHERE user_id = '{}'".format(
user_id)
self.connection.cursor.execute(query)
user_id = self.connection.cursor.fetchone()
print(user_id)
if user_id is None:
return False
else:
return True
# register intern
def register_intern(self, content):
print(content)
try:
user_id = content['user_id']
pw = content['pw']
date_registered = datetime.now()
# pw to hash
hash_pw = hashlib.sha256(str(pw).encode('utf-8')).hexdigest()
if self.exists(user_id):
payload = "user_id already registered", 200
print(payload)
return payload
else:
query = "INSERT INTO interns (user_id, pw_hash, date_registered) VALUES (%s, %s, %s)"
values = (user_id, hash_pw, date_registered)
self.connection.cursor.execute(query, values)
payload = "Intern registered successfully", 200
print(payload)
return payload
except Exception as e:
payload = "Error : " + str(e), 500
print(payload)
return payload
finally:
self.connection.conn.commit()
self.connection.close()
# update intern's info using user_id
def update_intern(self, user_id, content):
print(content)
if self.exists(user_id):
try:
email_id = content['email_id']
first_name = content['first_name']
last_name = content['last_name']
full_name = first_name + ' ' + last_name
image_url = content['image_url']
phone = content['phone']
country_code = content['country_code']
city = content['city']
state = content['state']
country = content['country']
date_updated = datetime.now()
except Exception as e:
payload = "invalid" + str(e), 500
print(payload)
return payload
query = "UPDATE interns SET" \
" email_id = %s," \
" first_name = %s," \
" last_name = %s," \
" full_name = %s," \
" image_url = %s, " \
" phone = %s," \
" country_code = %s," \
" city = %s," \
" state = %s," \
" country = %s," \
" date_updated = %s" \
" WHERE user_id = %s"
values = (email_id, first_name, last_name, full_name, image_url,
phone, country_code, city, state, country, date_updated,
user_id)
try:
self.connection.cursor.execute(query, values)
self.connection.conn.commit()
self.connection.close()
payload = "Intern updated successfully", 200
print(payload)
return payload
except Exception as e:
payload = "Error : " + str(e), 500
print(payload)
return payload
else:
self.connection.close()
payload = "Intern not registered", 200
print(payload)
return payload
# get intern using user_id
def get_intern(self, user_id):
try:
if self.exists(user_id):
query = "SELECT * FROM interns WHERE user_id = '{}'".format(
user_id)
print(query)
self.connection.cursor.execute(query)
user = self.connection.cursor.fetchone()
print(user)
# getting needed row headers.
row_header = [x[0] for x in self.connection.cursor.description]
print(row_header)
payload = {'status': 200, 'data': dict(zip(row_header, user))}
print(payload)
return payload
else:
payload = 'Intern not found'
print(payload)
return payload
except Exception as e:
payload = "Error : " + str(e), 500
print(payload)
return payload
finally:
self.connection.conn.commit()
self.connection.close()
# delete intern using user_id
def delete_intern(self, user_id):
try:
if self.exists(user_id):
query = "DELETE FROM interns WHERE user_id = '{}'".format(
user_id)
print(query)
self.connection.cursor.execute(query)
payload = "Intern deleted successfully", 200
print(payload)
return payload
else:
payload = "Intern not found", 200
print(payload)
return payload
except Exception as e:
payload = "Error : " + str(e), 500
print(payload)
return payload
finally:
self.connection.conn.commit()
self.connection.close()
def getAllCourseInfo(): conn = Connection.getConnection() cursor = conn.cursor() sql = "select * from course" cursor.execute(sql) return cursor.fetchall()
def __init__(self):
self.connection = Connection()
self.connection.connect_database()
class Skills:
def __init__(self):
self.connection = Connection()
self.connection.connect_database()
# check user exists or not
def exists(self, user_id):
query = "SELECT user_id FROM interns WHERE user_id = '{}'".format(
user_id)
self.connection.cursor.execute(query)
user_id = self.connection.cursor.fetchone()
print("user_id: ", user_id)
if user_id is None:
return False
else:
return True
# get existing skills
def current_skills(self, user_id):
# now get existing skills from database.
query = "SELECT skills FROM interns WHERE user_id = '{}'".format(
user_id)
self.connection.cursor.execute(query)
self.existing_skills = self.connection.cursor.fetchone()
return self.existing_skills[0]
# validation for empty skill and given information is in list format
def skill_validation(self, content):
try:
self.skills = content['skills']
except Exception as e:
self.payload = "Error " + str(e), 500
print(self.payload)
return self.payload
if type(self.skills) is not list:
self.payload = "given argument must be in list format", 200
print(self.payload)
return self.payload
if len(self.skills) == 0:
self.payload = "list can not be empty", 200
print(self.payload)
return self.payload
for skill in self.skills:
length = len(skill.strip())
if length == 0:
self.payload = "skill can not be empty", 200
print(self.payload)
return self.payload
if skill.isalnum() is False:
self.payload = "only alphanumeric allowed", 200
print(self.payload)
return self.payload
# get all skills in json format
def get_skills(self, user_id):
if self.exists(user_id):
query = "SELECT user_id, skills FROM interns WHERE user_id = '{}'".format(
user_id)
try:
self.connection.cursor.execute(query)
existing_skills = self.connection.cursor.fetchone()
print("existing_skills", existing_skills)
# getting needed row headers.
row_header = [x[0] for x in self.connection.cursor.description]
print("row_header", row_header)
self.connection.close()
# display data in json format
payload = {
'status': 200,
'data': dict(zip(row_header, existing_skills))
}
print(payload)
return payload
except Exception as e:
payload = "Error : " + str(e), 500
print(payload)
return payload
else:
self.connection.close()
payload = 'Intern not found'
print(payload)
return payload
# add skills
def add_skills(self, user_id, content):
# add skills
if self.skill_validation(content):
return self.payload
if self.exists(user_id):
# getting items in string format, will convert it into set.
requested_skills = set(self.skills)
print("requested_skills", requested_skills)
print("requested_skills get successfully")
# now we have only unique skills left, will convert into str.
skills = ','.join(requested_skills)
print("skills", skills, type(skills))
try:
# add skill to database
query = "UPDATE interns SET skills = %s WHERE user_id = %s"
values = (skills, user_id)
self.connection.cursor.execute(query, values)
self.connection.conn.commit()
self.connection.close()
payload = "skills successfully added", 200
print(payload)
return payload
except Exception as e:
self.connection.close()
payload = "Error: " + str(e), 500
print(payload)
return payload
else:
self.connection.close()
payload = "Intern not found", 404
print(payload)
return payload
# update skills
def update_skills(self, user_id, content):
if self.skill_validation(content):
return self.payload
if self.exists(user_id):
if self.current_skills(user_id) is None:
payload = "skills does not exist"
print(payload)
return payload
else:
# getting existing skills in tuple format, first convert into string then set.
self.existing_skills = set(','.join(
self.existing_skills).split(','))
# getting items in list format, will convert it into set.
requested_skills = set(self.skills)
print("requested_skills get successfully")
# we have two sets one is existing skills and second is requested skills.
# to add skills in database it must be in string format.
new_skills = ','.join(
self.existing_skills.union(requested_skills))
print("new_skills get successfully")
# add skills to database.
query = "UPDATE interns SET skills = %s WHERE user_id = %s"
values = (new_skills, user_id)
try:
self.connection.cursor.execute(query, values)
self.connection.conn.commit()
payload = "skills successfully updated", 200
print(payload)
return payload
except Exception as e:
payload = "Error: " + str(e), 500
print(payload)
return payload
finally:
self.connection.close()
else:
self.connection.close()
payload = "Intern not found", 404
print(payload)
return payload
# delete skills
def delete_skills(self, user_id, content):
if self.skill_validation(content):
return self.payload
if self.exists(user_id):
if self.current_skills(user_id) is None:
payload = "nothing added in skills yet"
print(payload)
return payload
else:
# getting existing skills in tuple format, first convert into string then set.
self.existing_skills = set(','.join(
self.existing_skills).split(','))
# getting items in string format, will convert it into set.
requested_skills = set(self.skills)
print("requested_skills get successfully")
# from existing skills remove requested skills.
payload = []
for requested_skill in requested_skills:
if requested_skill in self.existing_skills:
self.existing_skills.remove(requested_skill)
# to add skills in database it must be in string format.
new_skills = ','.join(set(self.existing_skills))
print("new_skills", new_skills)
print("new_skills get successfully")
# add skills to database.
query = "UPDATE interns SET skills = %s WHERE user_id = %s"
values = (new_skills, user_id)
try:
self.connection.cursor.execute(query, values)
self.connection.conn.commit()
payload = "skills deleted successfully " + requested_skill, 200
print(payload)
except Exception as e:
payload = "Error: " + str(e), 500
print(payload)
return payload
finally:
self.connection.close()
else:
payload = "skills does not exist " + requested_skill, 404
print(payload)
return payload
else:
self.connection.close()
payload = "Intern not found", 404
print(payload)
return payload
def client():
"""Client mode work flow."""
downlink = Connection('downlink', 'r')
uplink = Connection('uplink', 'w+')
# Establish connection
dh = DiffieHellman()
p, g = dh.get_pg()
uplink.send('INIT,{0},{1}'.format(p, g))
response = get_response(downlink, 'MY_PUBLIC', 2,
'Failed to authenticate via DH')
public = dh.get_my_public()
uplink.send('MY_PUBLIC,{0}'.format(public))
key = dh.compute_shared(response[1])
logging.debug('Key established: {0}'.format(key.hexdigest()))
# Start encrypted communication
response = get_response(downlink, 'AES', 2, 'Failed to start AES')
aes = AES.new(key.digest(), AES.MODE_CBC, b64decode(response[1]))
# Verify identity using FFS
while True:
ffs = FFSProver()
# Send X
msg = msg_encrypt(aes, str(ffs.get_x()))
uplink.send('FFS_X,{0}'.format(msg))
# Get A vector
response = get_response(downlink, 'FFS_A', 2,
'Failed to verify identity via FFS')
a_vector = [int(a) for a in msg_decrypt(aes, response[1])]
# Solve Y
msg = msg_encrypt(aes, str(ffs.solve(a_vector)))
uplink.send('FFS_Y,{0}'.format(msg))
# Get result
response = next(downlink.receive())
if response not in ('FFS_OK', 'FFS_DONE'):
raise RuntimeError('Failed to verify identity via FFS')
if response == 'FFS_DONE':
break
# Send messages
print('Connection established, communication channel open.')
print('If you want to end this program press CTRL(C')
while True:
# Snd message
raw_msg = raw_input('Enter message: ')
msg = msg_encrypt(aes, raw_msg)
uplink.send('MSG,{0}'.format(msg))
# Get response
response = next(downlink.receive())
response = response.split(',')
if len(response) != 2 or response[0] != 'SHA256':
raise RuntimeError('Channel compromised')
# Compare Hashes
our_hash = sha256(raw_msg).hexdigest()
their_hash = msg_decrypt(aes, response[1])
print('Recieved: ' + their_hash)
if their_hash != our_hash:
print('Hash mismatch!')
raise RuntimeError('Channel compromised')
else:
print('Hash matches')
class Education:
def __init__(self):
self.connection = Connection()
self.connection.connect_database()
def education_validation(self, content):
try:
self.content = content
for edu in self.content:
# check dictionary is empty or not
if not edu:
self.payload = "dictionary can not be empty", 200
return self.payload
if type(edu['type']) is not str:
self.payload = "degree type must be string", 200
return self.payload
if type(edu['name']) is not str:
self.payload = "degree name must be string", 200
return self.payload
if type(edu['is_completed']) is not bool:
self.payload = "is_completed must be boolean", 200
return self.payload
if type(edu['year']) is not list:
self.payload = "degree year must be list", 200
return self.payload
# check year is int or not
for year in edu['year']:
if type(year) is not int:
self.payload = "degree year must be int", 200
return self.payload
if len(edu['year']) > 2:
self.payload = 'year exceeds the maximum allowed length of 2', 200
return self.payload
except Exception as e:
payload = "Error : " + str(e), 500
print(payload)
return payload
def add_education(self, user_id, content):
if self.education_validation(content):
return self.payload
if skills.exists(user_id):
query = "UPDATE interns SET education = %s WHERE user_id = %s"
values = (str(self.content), user_id)
try:
self.connection.cursor.execute(query, values)
self.connection.conn.commit()
self.connection.close()
payload = "education successfully updated", 200
print(payload)
return payload
except Exception as e:
payload = "Error : " + str(e), 500
print(payload)
return payload
else:
payload = "intern not found", 200
print(payload)
return payload
def get_education(self, user_id):
query = "SELECT user_id, education FROM interns WHERE user_id = '{}'".format(
user_id)
self.connection.cursor.execute(query)
existing_education = self.connection.cursor.fetchone()
print("existing_education : ", existing_education)
row_header = [x[0] for x in self.connection.cursor.description]
print("row_header : ", row_header)
self.connection.close()
payload = {
'status': 200,
'data': dict(zip(row_header, existing_education))
}
print(payload)
return payload
def __init__(self, host='127.0.0.1', port=11211):
self.conn = Connection(host, port)
self.conn.connect()
class McdClient():
def __init__(self, host='127.0.0.1', port=11211):
self.conn = Connection(host, port)
self.conn.connect()
def stats(self, type = ''):
op = Stats(type)
self.conn.queue_operation(op)
return op
def set(self, key, value, vbucket, flags, exp):
op = Set(key, value, vbucket, flags, exp)
self.conn.queue_operation(op)
return op
def delete(self, key, vbucket):
op = Delete(key, vbucket)
self.conn.queue_operation(op)
return op
def flush(self):
op = Flush()
self.conn.queue_operation(op)
return op
def shutdown(self):
self.conn.close()
def getAllStudentInfo(): conn = Connection.getConnection() cursor = conn.cursor() sql = "select * from student" cursor.execute(sql) return cursor.fetchall()
from conn import Connection
# create object for class "Connection"
connection = Connection()
# create database "terntop"
try:
connection.cursor.execute("CREATE DATABASE terntop")
print('database created successfully')
except Exception as e:
print('Error: ', str(e))
# connect to sql database "terntop"
connection.connect_database()
# create table "interns"
try:
connection.cursor.execute(
"CREATE TABLE interns (user_id VARCHAR(10) NOT NULL UNIQUE PRIMARY KEY, "
"email_id VARCHAR(50), pw_hash VARCHAR(100) NOT NULL, "
"first_name VARCHAR(20), last_name VARCHAR(40), full_name VARCHAR(20),"
"image_url TEXT,phone BIGINT(10),country_code VARCHAR(2), city VARCHAR(20),"
"state VARCHAR(20), country VARCHAR(20) ,date_registered TIMESTAMP, "
"date_updated TIMESTAMP, skills TEXT, education TEXT,"
"experience TEXT, applications TEXT)")
print('"interns" table created successfully')
except Exception as e:
print(str(e))
# create table "employers"
try:
# 生成账号信息
student_accounts = []
for i in range(0, 100):
student_accounts.append((student_id[i], 'test', student_id[i]))
# 生成工号
teacher_ids = np.arange(1, 11, 1)
# 随机生成教师信息
teacher_infos = []
for i in range(0, 10):
teacher_infos.append((teacher_ids[i], createName(), \
createGender(), u'电子科学与工程学院', \
createRank(), createPhoneNum()))
conn = Connection.getConnection()
cursor = conn.cursor()
cursor.execute("select * from teach")
resultList = cursor.fetchall()
# 生成课程信息
course_infos = [\
(1, u'计算方法', u'仙林校区 逸B-105', u'周二 第5-7节 1-18周', u'选修', u'电子科学与工程学院'), \
(2, u'微波测量实验', u'仙林校区 仙林电子楼239室', u'周五 第5-6节 1-18周', u'核心', u'电子科学与工程学院'), \
(3, u'操作系统', u'仙林校区 仙Ⅰ-115', u'周一 第3-4节 1-18周', u'选修', u'电子科学与工程学院'), \
(4, u'矩阵计算与应用', u'仙林校区 仙Ⅰ-115', u'周一 第9-10节 1-18周', u'选修', u'电子科学与工程学院'), \
(5, u'IT企业创业与发展战略', u'仙林校区 仙Ⅱ-304', u' 周二 第9-10节 1-18周', u'选修', u'电子科学与工程学院'), \
(6, u'数据通信', u'仙林校区 仙Ⅰ-206', u' 周四 第5-7节 1-18周', u'选修', u'电子科学与工程学院'), \
(7, u'微电子工艺', u'仙林校区 仙Ⅰ-104', u'周一 仙Ⅰ-104 1-18周', u'选修', u'电子科学与工程学院'), \
(8, u'数字集成电路设计', u'仙林校区 仙Ⅰ-115', u'周一 第5-7节 1-12周', u'选修', u'电子科学与工程学院'), \
(9, u'电子系统实践', u'仙林校区 仙Ⅰ-115 ', u'周一 第5-7节 1-12周', u'选修', u'电子科学与工程学院'), \
my_url = f"http://localhost:{settings.PORT_NUMBER}" + ('/setup' if setup_mode else '')
logging.info(f"Web server at: {my_url}")
# meh; kinda annoying.
if 0:
def popup():
try:
# see <https://github.com/jupyter/notebook/issues/3746#issuecomment-444957821>
# if this doesn't happen on MacOS
from webbrowser import open as open_browser
open_browser(my_url)
except:
logging.error("Unable to pop browser open", exc_info=1)
asyncio.get_running_loop().call_later(3, popup)
from aiohttp.abc import AbstractAccessLogger
class AccessLogger(AbstractAccessLogger):
def log(self, request, response, time):
self.logger.info(f'{response.status} <= {request.method} {request.path}')
return web._run_app(app, port=settings.PORT_NUMBER, print=None, access_log_class=AccessLogger)
if __name__ == "__main__":
from utils import setup_logging
setup_logging()
dev = Connection(None) # won't do anything tho, because async dev.run not called
asyncio.run(startup())
# EOF
async def ws_api_handler(ses, send_json, req, orig_request): # handle_api
#
# Handle incoming requests over websocket; send back results.
# req = already json parsed request coming in
# send_json() = means to send the response back
#
action = req.action
args = getattr(req, 'args', None)
#logging.warn("API action=%s (%r)" % (action, args)) # MAJOR info leak XXX
logging.debug(f"API action={action}")
if action == '_connected':
logging.info("Websocket connected: %r" % args)
# can send special state update at this point, depending on the page
elif action == 'start_hsm_btn':
await Connection().hsm_start()
await send_json(show_flash_msg=APPROVE_CTA)
elif action == 'delete_user':
name, = args
assert 1 <= len(name) <= MAX_USERNAME_LEN, "bad username length"
await Connection().delete_user(name.encode('utf8'))
# assume it worked, so UX updates right away
try:
STATUS.hsm.users.remove(name)
except ValueError:
pass
STATUS.notify_watchers()
elif action == 'create_user':
name, authmode, new_pw = args
assert 1 <= len(name) <= MAX_USERNAME_LEN, "bad username length"
assert ',' not in name, "no commas in names"
if authmode == 'totp':
mode = USER_AUTH_TOTP | USER_AUTH_SHOW_QR
new_pw = ''
elif authmode == 'rand_pw':
mode = USER_AUTH_HMAC | USER_AUTH_SHOW_QR
new_pw = ''
elif authmode == 'give_pw':
mode = USER_AUTH_HMAC
else:
raise ValueError(authmode)
await Connection().create_user(name.encode('utf8'), mode, new_pw)
# assume it worked, so UX updates right away
try:
STATUS.hsm.users = list(set(STATUS.hsm.users + [name]))
except ValueError:
pass
STATUS.notify_watchers()
elif action == 'submit_policy':
# get some JSON w/ everything the user entered.
p, save_copy = args
proposed = policy.web_cleanup(json_loads(p))
policy.update_sl(proposed)
await Connection().hsm_start(proposed)
STATUS.notify_watchers()
await send_json(show_flash_msg=APPROVE_CTA)
if save_copy:
d = policy.desensitize(proposed)
await send_json(local_download=dict(data=json_dumps(d, indent=2),
filename=f'hsm-policy-{STATUS.xfp}.json.txt'))
elif action == 'download_policy':
proposed = policy.web_cleanup(json_loads(args[0]))
await send_json(local_download=dict(data=json_dumps(proposed, indent=2),
filename=f'hsm-policy-{STATUS.xfp}.json.txt'))
elif action == 'import_policy':
# they are uploading a JSON capture, but need values we can load in Vue
proposed = args[0]
cooked = policy.web_cookup(proposed)
await send_json(vue_app_cb=dict(update_policy=cooked),
show_flash_msg="Policy file imported.")
elif action == 'pick_onion_addr':
from torsion import TOR
addr, pk = await TOR.pick_onion_addr()
await send_json(vue_app_cb=dict(new_onion_addr=[addr, pk]))
elif action == 'pick_master_pw':
pw = b64encode(os.urandom(12)).decode('ascii')
pw = pw.replace('/', 'S').replace('+', 'p')
assert '=' not in pw
await send_json(vue_app_cb=dict(new_master_pw=pw))
elif action == 'new_bunker_config':
from torsion import TOR
# save and apply config values
nv = json_loads(args[0])
assert 4 <= len(nv.master_pw) < 200, "Master password must be at least 4 chars long"
# copy in simple stuff
for fn in [ 'tor_enabled', 'master_pw', 'easy_captcha', 'allow_reboots']:
if fn in nv:
BP[fn] = nv[fn]
# update onion stuff only if PK is known (ie. they changed it)
if nv.get('onion_pk', False) or False:
for fn in [ 'onion_addr', 'onion_pk']:
if fn in nv:
BP[fn] = nv[fn]
BP.save()
await send_json(show_flash_msg="Bunker settings encrypted and saved to disk.")
STATUS.tor_enabled = BP['tor_enabled']
STATUS.notify_watchers()
if not BP['tor_enabled']:
await TOR.stop_tunnel()
elif BP.get('onion_pk') and not (STATUS.force_local_mode or STATUS.setup_mode) \
and TOR.get_current_addr() != BP.get('onion_addr'):
# disconnect/reconnect
await TOR.start_tunnel()
elif action == 'sign_message':
# sign a short text message
# - lots more checking could be done here, but CC does it anyway
msg_text, path, addr_fmt = args
addr_fmt = AF_P2WPKH if addr_fmt != 'classic' else AF_CLASSIC
try:
sig, addr = await Connection().sign_text_msg(msg_text, path, addr_fmt)
except:
# get the spinner to stop: error msg will be "refused by policy" typically
await send_json(vue_app_cb=dict(msg_signing_result='(failed)'))
raise
sig = b64encode(sig).decode('ascii').replace('\n', '')
await send_json(vue_app_cb=dict(msg_signing_result=f'{sig}\n{addr}'))
elif action == 'upload_psbt':
# receiving a PSBT for signing
size, digest, contents = args
psbt = b64decode(contents)
assert len(psbt) == size, "truncated/padded in transit"
assert sha256(psbt).hexdigest() == digest, "corrupted in transit"
STATUS.import_psbt(psbt)
STATUS.notify_watchers()
elif action == 'clear_psbt':
STATUS.clear_psbt()
STATUS.notify_watchers()
elif action == 'preview_psbt':
STATUS.psbt_preview = 'Wait...'
STATUS.notify_watchers()
try:
txt = await Connection().sign_psbt(STATUS._pending_psbt, flags=STXN_VISUALIZE)
txt = txt.decode('ascii')
# force some line splits, especially for bech32, 32-byte values (p2wsh)
probs = re.findall(r'([a-zA-Z0-9]{36,})', txt)
for p in probs:
txt = txt.replace(p, p[0:30] + '\u22ef\n\u22ef' + p[30:])
STATUS.psbt_preview = txt
except:
# like if CC doesn't like the keys, whatever ..
STATUS.psbt_preview = None
raise
finally:
STATUS.notify_watchers()
elif action == 'auth_set_name':
idx, name = args
assert 0 <= len(name) <= MAX_USERNAME_LEN
assert 0 <= idx < len(STATUS.pending_auth)
STATUS.pending_auth[idx].name = name
STATUS.notify_watchers()
elif action == 'auth_offer_guess':
idx, ts, guess = args
assert 0 <= idx < len(STATUS.pending_auth)
STATUS.pending_auth[idx].totp = ts
STATUS.pending_auth[idx].has_guess = 'x'*len(guess)
STATUS._auth_guess[idx] = guess
STATUS.notify_watchers()
elif action == 'submit_psbt':
# they want to sign it now
expect_hash, send_immediately, finalize, wants_dl = args
assert expect_hash == STATUS.psbt_hash, "hash mismatch"
if send_immediately: assert finalize, "must finalize b4 send"
logging.info("Starting to sign...")
STATUS.busy_signing = True
STATUS.notify_watchers()
try:
dev = Connection()
# do auth steps first (no feedback given)
for pa, guess in zip(STATUS.pending_auth, STATUS._auth_guess):
if pa.name and guess:
await dev.user_auth(pa.name, guess, int(pa.totp), a2b_hex(STATUS.psbt_hash))
STATUS.reset_pending_auth()
try:
result = await dev.sign_psbt(STATUS._pending_psbt, finalize=finalize)
logging.info("Done signing")
msg = "Transaction signed."
if send_immediately:
msg += '<br><br>' + broadcast_txn(result)
await send_json(show_modal=True, html=Markup(msg), selector='.js-api-success')
result = (b2a_hex(result) if finalize else b64encode(result)).decode('ascii')
fname = 'transaction.txt' if finalize else ('signed-%s.psbt'%STATUS.psbt_hash[-6:])
if wants_dl:
await send_json(local_download=dict(data=result, filename=fname,
is_b64=(not finalize)))
await dev.hsm_status()
except CCUserRefused:
logging.error("Coldcard refused to sign txn")
await dev.hsm_status()
r = STATUS.hsm.get('last_refusal', None)
if not r:
raise HTMLErroMsg('Refused by local user.')
else:
raise HTMLErrorMsg(f"Rejected by Coldcard.<br><br>{r}")
finally:
STATUS.busy_signing = False
STATUS.notify_watchers()
elif action == 'shutdown_bunker':
await send_json(show_flash_msg="Bunker is shutdown.")
await asyncio.sleep(0.25)
logging.warn("User-initiated shutdown")
asyncio.get_running_loop().stop()
sys.exit(0)
elif action == 'leave_setup_mode':
# During setup process, they want to go Tor mode; which I consider leaving
# setup mode ... in particular, logins are required.
# - button label is "Start Tor" tho ... so user doesn't see it that way
assert STATUS.setup_mode, 'not in setup mode?'
assert BP['tor_enabled'], 'Tor not enabled (need to save?)'
addr = BP['onion_addr']
assert addr and '.onion' in addr, "Bad address?"
STATUS.setup_mode = False
await send_json(show_flash_msg="Tor hidden service has been enabled. "
"It may take a few minutes for the website to become available")
STATUS.notify_watchers()
from torsion import TOR
logging.info(f"Starting hidden service: %s" % addr)
asyncio.create_task(TOR.start_tunnel())
elif action == 'logout_everyone':
# useful for running battles...
# - changes crypto key for cookies, so they are all invalid immediately.
from aiohttp_session.nacl_storage import NaClCookieStorage
import nacl
logging.warning("Logout of everyone!")
# reset all session cookies
storage = orig_request.get('aiohttp_session_storage')
assert isinstance(storage, NaClCookieStorage)
storage._secretbox = nacl.secret.SecretBox(os.urandom(32))
# kick everyone off (bonus step)
for w in web_sockets:
try:
await send_json(redirect='/logout', _ws=w)
await w.close()
except:
pass
else:
raise NotImplementedError(action)
def getCourseInfoById(id): conn = Connection.getConnection() cursor = conn.cursor() sql = "select * from course where course_id = %d"%(id) cursor.execute(sql) return cursor.fetchall()
class UprClient():
def __init__(self, host='127.0.0.1', port=11211):
self.conn = Connection(host, port)
self.conn.connect()
def set_proxy(self, client):
self.conn.proxy = client.conn.socket
def open_consumer(self, name):
op = OpenConnection(FLAG_OPEN_CONSUMER, name)
self.conn.queue_operation(op)
return op
def open_producer(self, name):
op = OpenConnection(FLAG_OPEN_PRODUCER, name)
self.conn.queue_operation(op)
return op
def add_stream(self, vbucket, flags):
op = AddStream(vbucket, flags)
self.conn.queue_operation(op)
return op
def close_stream(self, vbucket):
op = CloseStream(vbucket)
self.conn.queue_operation(op)
return op
def get_failover_log(self, vbucket):
op = GetFailoverLog(vbucket)
self.conn.queue_operation(op)
return op
def stream_req(self, vb, flags, start_seqno, end_seqno, vb_uuid, hi_seqno):
op = StreamRequest(vb, flags, start_seqno, end_seqno, vb_uuid, hi_seqno)
self.conn.queue_operation(op)
return op
def shutdown(self):
self.conn.close()
