def check(self):
steamvr_running = self.is_steamvr_running()
# log.d('Stage: {} steamvr_running {}'.format(self.current_stage, steamvr_running))
if self.current_stage == self.Stages.BEFORE_STEAMVR:
if steamvr_running:
self.update_stage(self.Stages.DURING_STEAMVR)
elif self.start_of_current_stage + 60 <= time.time():
log.e("SteamVR never started, exiting. Looking for a process with this name: {}".format(
self.config.daemon_watch_process_name()))
self.steamvr_utils.turn_off()
log.i("Exiting...")
return False
elif self.current_stage == self.Stages.DURING_STEAMVR:
if not steamvr_running:
self.update_stage(self.Stages.AFTER_STEAMVR)
elif self.current_stage == self.Stages.AFTER_STEAMVR:
if steamvr_running:
self.update_stage(self.Stages.DURING_STEAMVR)
elif self.start_of_current_stage + self.config.daemon_wait_after_quit() <= time.time():
self.steamvr_utils.turn_off()
log.i("Exiting...")
return False
return True
def _local(self, line):
cmd, tail = util.parse_cmdline2(line,
kermit.kermit_cmds['local'].subcmds,
log)
k = self.kermit
if cmd == 'cwd':
k.local_cwd(tail)
elif cmd == 'delete':
k.local_delete(tail)
elif cmd == 'directory':
k.local_directory(tail)
elif cmd == 'path':
k.local_path()
elif cmd == 'push':
k.local_push()
elif cmd == 'run':
k.local_run(tail)
elif cmd == 'space':
k.local_space()
elif cmd == 'type':
k.local_type(tail)
else:
log.i('Invalid local command: {}'.format(line))
def _send_packets(self, packets):
ignore_response = self.config['ignorerx'].value
ignorerx = self.config['ignore-sec'].value
send_max_retries = 6 # Arbitrary
i = 0
retries = 0
while i < len(packets):
if retries > send_max_retries:
return False
log.i('Sending packet #{} of {}'.format(i + 1, len(packets)))
pkt = self._write_verify(packets[i], ignore_response)
if pkt:
if pkt.type == 'E':
return False
if packets[i].type == 'S':
self.set_receive_params(pkt)
i += 1
retries = 0
continue
elif ignore_response:
time.sleep(ignorerx)
i += 1
continue
else:
log.i('Failed to send packet')
retries += 1
return True
def create_daemon(cls, steamvr_utils):
# TODO: causes process to end itself
# kill other instances of this deamon to make sure only one is running at any given time
# subprocess.run(['killall', 'steamvr_utils.py d'])
# based on: https://code.activestate.com/recipes/278731-creating-a-daemon-the-python-way/
pid = os.fork()
if pid == 0:
# First Child
pid = os.fork()
if pid == 0:
# Second Child
os.chdir('/')
steamvr_daemon = cls(steamvr_utils)
steamvr_daemon.loop()
sys.exit()
else:
# First Child
sys.exit()
else:
# Parent
log.i(
'Logging to stdout will now stop. See log file at: {}'.format(
steamvr_utils.config.log_path()))
sys.exit()
def WinHttpOpen_entry_hook(hc, dbg): info = HTTPOpenSession(dbg.pid, dbg.tid, user_agent= hc.read_string_auto(dbg, "pwszUserAgent"), proxy = hc.read_string_auto(dbg, "pwszProxyName"), bypass = hc.read_string_auto(dbg, "pwszProxyBypass")) info.save() log.i(info.brief_info(), dbg)
def send_chars(self, chars):
log.i('Sending chars: {}'.format(chars))
if len(chars) > 255:
log.w("Text length exceeds calc's buffer size (255 chars).")
parity_bytes = util.set_parity(bytearray(chars),
int(self.config['parity'].value))
self.transport.write_bytes(parity_bytes)
def WriteFile_exit_hook(hc, dbg): size = hc.read_dword(dbg, "lpNumberOfBytesWritten") info = WriteFileEvent(dbg.pid, dbg.tid, size = size, data = hc.read_data(dbg, "lpBuffer", size)) info.save() log.i(info.brief_info(),dbg)
def action(self, action):
def attempt_loop(function, max_attempts, try_all=False):
attempt_count = 0
success_count = 0
last_error = None
while attempt_count < max_attempts:
try:
if try_all:
function()
else:
return function()
success_count += 1
log.i('Success of attempt {} of {}'.format(
attempt_count + 1, max_attempts))
except Exception as e:
last_error = e
log.e('Failure of attempt {} of {}: {}'.format(
attempt_count + 1, max_attempts, e))
attempt_count += 1
time.sleep(0.5) # to increase robustness
if success_count == 0:
log.e(
'No successful attempt in any of the {} attempts. Last error:'
.format(max_attempts))
raise last_error
log.i("Scanning for Base Stations:")
attempt_loop(lambda: self.scan(),
self.config.basestation_attempt_count_scan())
log.i("Changing power state of Base Stations:")
attempt_loop(lambda: self.action_attempt(action),
self.config.basestation_attempt_count_set(),
try_all=True)
def fetch_cna(self):
def quote_cna(val):
if '%' in val:
return val
return urllib.parse.quote(val)
cook = cookiejar.CookieJar()
if cookies:
for cookie in cook:
if cookie.name == 'cna' and cookie.domain == '.youku.com':
log.i('Found cna in imported cookies. Use it')
return quote_cna(cookie.value)
url = 'http://log.mmstat.com/eg.js'
#url = 'http://gm.mmstat.com/yt/ykcomment.play.commentInit?cna='
req = urllib.request.urlopen(url)
headers = req.getheaders()
for header in headers:
if header[0].lower(
) == 'set-cookie': #元组中第0项字符串转换为小写对比是不是'set-cookie'
n_v = header[1].split(';')[0] #根据分好分割出cna
name, value = n_v.split('=') #根据分好分割出cna字段
if name == 'cna':
return quote_cna(value)
log.w(
'It seems that the client failed to fetch a cna cookie. Please load your own cookie if possible'
)
return quote_cna('DOG4EdW4qzsCAbZyXbU+t7Jt')
def send_entry_hook(hc, dbg):
info = SocketSendEvent(dbg.pid,
dbg.tid,
length=hc.args["len"],
data=hc.read_data(dbg, "buf", "len"))
info.save()
log.i(info.brief_info(), dbg)
def get(self, line):
hp_names = shlex.split(line)
if hp_names:
for hp_name in hp_names:
self._get(hp_name)
else:
log.i('Invalid or missing name: {}'.format(line))
def attempt_loop(function, max_attempts, try_all=False):
attempt_count = 0
success_count = 0
last_error = None
while attempt_count < max_attempts:
try:
if try_all:
function()
else:
return function()
success_count += 1
log.i('Success of attempt {} of {}'.format(
attempt_count + 1, max_attempts))
except Exception as e:
last_error = e
log.e('Failure of attempt {} of {}: {}'.format(
attempt_count + 1, max_attempts, e))
attempt_count += 1
time.sleep(0.5) # to increase robustness
if success_count == 0:
log.e(
'No successful attempt in any of the {} attempts. Last error:'
.format(max_attempts))
raise last_error
def recv_exit_hook(hc, dbg): info = SocketRecvEvent(dbg.pid, dbg.tid, length=hc.ret_value, data = hc.read_data(dbg, "buf", hc.ret_value)) info.save() log.i(info.brief_info(), dbg)
def listen(self, tail=''):
parts = (tail + ' x x').split()[0:2]
nap_count = util.parse_int(parts[0], 30)
nap_time = util.parse_float(parts[1], 1)
for i in range(0, nap_count):
log.i([chr(b) for b in self.transport.peek()])
time.sleep(nap_time)
def WinHttpOpenRequest_entry_hook(hc, dbg):
#log.i("Verb:%s" % hc.read_string_auto(dbg,"pwszVerb"))
#log.i("Path:%s"% hc.read_string_auto(dbg, "pwszObjectName"))
#log.i("Version:%s"% hc.read_string_auto(dbg, "pwszVersion"))
#log.i("Referer:%s"% hc.read_string_auto(dbg, "pwszReferrer"))
#log.i("AcceptType:")
offset = 0
accept_type = []
while 1:
ptr = hc.read_dword(dbg, "ppwszAcceptTypes", offset)
if ptr == 0L:
break
#log.i(hc.read_string_auto(dbg,ptr))
accept_type.append(hc.read_string_auto(dbg, ptr))
offset += 4
pass
accept_type = " ".join(accept_type)
info = HTTPOpenRequestEvent(
dbg.pid,
dbg.tid,
verb=hc.read_string_auto(dbg, "pwszVerb"),
path=hc.read_string_auto(dbg, "pwszObjectName"),
version=hc.read_string_auto(dbg, "pwszVersion"),
referer=hc.read_string_auto(dbg, "pwszReferrer"),
accept_type=accept_type)
info.save()
log.i(info.brief_info(), dbg)
def _remote(self, line):
cmd, tail = util.parse_cmdline2(line,
kermit.kermit_cmds['remote'].subcmds,
log)
k = self.kermit
if cmd == 'cwd':
k.remote_cwd(tail)
elif cmd == 'delete':
k.remote_delete(tail)
elif cmd == 'directory':
k.remote_directory()
elif cmd == 'host':
if tail:
k.remote_host(tail)
else:
self._hpcalc()
elif cmd == 'path': # Not in Kermit specification
k.remote_path()
elif cmd == 'space':
k.remote_space()
elif cmd == 'type':
k.remote_type(tail)
else:
log.i('Invalid remote command: {}'.format(line))
def WinHttpConnect_entry_hook(hc, dbg):
info = HTTPConnectEvent(dbg.pid,
dbg.tid,
server=hc.read_string_auto(dbg, "pswzServerName"),
port=hc.get_value("nServerPort"))
info.save()
log.i(info.brief_info(), dbg)
def RegOpenKeyEx_exit_hook(hc, dbg): info = RegOpenEvent(dbg.pid, dbg.tid, h_key = _h_key(hc.args["hKey"]), sub_key = hc.read_string_auto(dbg, "lpSubKey"), out_hkey = hex(hc.read_dword(dbg,"phkResult"))) info.save() log.i(info.brief_info(),dbg)
def WinHttpOpenRequest_entry_hook(hc, dbg):
#log.i("Verb:%s" % hc.read_string_auto(dbg,"pwszVerb"))
#log.i("Path:%s"% hc.read_string_auto(dbg, "pwszObjectName"))
#log.i("Version:%s"% hc.read_string_auto(dbg, "pwszVersion"))
#log.i("Referer:%s"% hc.read_string_auto(dbg, "pwszReferrer"))
#log.i("AcceptType:")
offset = 0
accept_type = []
while 1:
ptr = hc.read_dword(dbg,"ppwszAcceptTypes", offset)
if ptr == 0L:
break
#log.i(hc.read_string_auto(dbg,ptr))
accept_type.append(hc.read_string_auto(dbg,ptr))
offset += 4
pass
accept_type = " ".join(accept_type)
info = HTTPOpenRequestEvent(dbg.pid, dbg.tid,
verb = hc.read_string_auto(dbg,"pwszVerb"),
path = hc.read_string_auto(dbg, "pwszObjectName"),
version = hc.read_string_auto(dbg, "pwszVersion"),
referer = hc.read_string_auto(dbg, "pwszReferrer"),
accept_type = accept_type)
info.save()
log.i(info.brief_info(), dbg)
def _send_files(self, files, is_text):
num_files = len(files)
if num_files == 0:
raise Exception('No files to send')
for i, file in enumerate(files):
if num_files > 1:
log.i('Sending file {} of {}'.format(i + 1, num_files))
self._send_file(file, is_text, None)
def _hpcalc(self):
log.i('Press Ctrl-C to quit')
try:
while True:
self.kermit.send_command(
raw_input('{}{}'.format('hpcalc', PROMPTER)))
except KeyboardInterrupt:
log.i('')
def turn_off(self):
log.i('SteamvrUtils turning off:')
if self.basestation_power_interface is not None:
self.basestation_power_interface.action(basestation_interface.Action.OFF)
if self.audio_switcher is not None:
self.audio_switcher.switch_to_normal()
def WriteFile_exit_hook(hc, dbg):
size = hc.read_dword(dbg, "lpNumberOfBytesWritten")
info = WriteFileEvent(dbg.pid,
dbg.tid,
size=size,
data=hc.read_data(dbg, "lpBuffer", size))
info.save()
log.i(info.brief_info(), dbg)
def recv_exit_hook(hc, dbg):
info = SocketRecvEvent(dbg.pid,
dbg.tid,
length=hc.ret_value,
data=hc.read_data(dbg, "buf", hc.ret_value))
info.save()
log.i(info.brief_info(), dbg)
def _write_file(self, filename, bytes):
if filename == 'STDOUT':
print(self._to_chars(bytes))
else:
f = open(filename, 'w')
f.write(bytearray(bytes))
f.close()
log.i('Wrote file ' + filename)
def RegOpenKeyEx_exit_hook(hc, dbg):
info = RegOpenEvent(dbg.pid,
dbg.tid,
h_key=_h_key(hc.args["hKey"]),
sub_key=hc.read_string_auto(dbg, "lpSubKey"),
out_hkey=hex(hc.read_dword(dbg, "phkResult")))
info.save()
log.i(info.brief_info(), dbg)
def filenames_from_specs(specs):
lst = []
for spec in shlex.split(specs):
files = glob.glob(spec)
lst.extend(files)
if not files:
log.i('No files found for {}'.format(spec))
return lst
def local_type(self, filename):
if filename:
f = open(filename, 'r')
lines = f.read()
f.close()
log.i(lines)
else:
log.e('Missing filename')
def turn_on(self):
log.i('SteamvrUtils turning on:')
if self.basestation_power_interface is not None:
self.basestation_power_interface.action(basestation_interface.Action.ON)
if self.audio_switcher is not None:
self.audio_switcher.switch_to_vr()
def WinHttpSendRequest_entry_hook(hc,dbg):
#log.i("Headers:%s"% hc.read_string_auto(dbg, "pwszHeaders"))
#log.i("Optionals:%s"% hc.read_string_auto(dbg, "lpOptional"))
info = HttpSendRequestEvent(dbg.pid, dbg.tid,
headers = hc.read_string_auto(dbg, "pwszHeaders"),
optionals = hc.read_string_auto(dbg, "lpOptional"))
info.save()
log.i(info.brief_info(), dbg)
def RegSetValueEx_entry_hook(hc, dbg): info = RegSetEvent(dbg.pid, dbg.tid, h_key = _h_key(hc.args["hKey"]), name = hc.read_string_auto(dbg, "lpValueName"), size = hc.args["cbData"], data = hc.read_string_auto(dbg, "lpData")) info.save() log.i(info.brief_info(),dbg)
def write_packet(self, pkt):
if not pkt:
log.e('No packet to write')
return False
lst = pkt.to_list()
if self.config['debug'].value:
log.i('Sending {}'.format(lst))
self.transport.write_bytes(bytearray(lst))
return True
def get( self ) :
log.i( 'hello word' )
#log.i( 'hello word' % (self.ss_user['uid']) )
name = self.get_argument( 'name', default='yexiang' )
msg = 'hello ' + name
res = { 'op':True, 'msg':msg }
self.write( json.dumps(res) )
self.finish()
return
def send_file(self, filename):
log.i('Sending file: {}'.format(filename))
if filename == 'STDIN':
self.send_chars(sys.stdin.read())
else:
f = open(filename, 'r')
chars = f.read()
f.close()
self.send_chars(chars)
def WinHttpOpen_entry_hook(hc, dbg):
info = HTTPOpenSession(dbg.pid,
dbg.tid,
user_agent=hc.read_string_auto(
dbg, "pwszUserAgent"),
proxy=hc.read_string_auto(dbg, "pwszProxyName"),
bypass=hc.read_string_auto(dbg, "pwszProxyBypass"))
info.save()
log.i(info.brief_info(), dbg)
def set(self, line):
cmd, tail = util.parse_cmdline2(line, self.config, log)
if not cmd:
log.e('Name not found: {}'.format(line))
return
if cmd == 'receive':
log.i('Cannot set receive')
return
util.set_config(line, self.config, kprotocol.C, log)
def ReadFile_exit_hook(hc, dbg): #log.i( "File Content: %s" % hc.read_data(dbg, "lpBuffer", "nNumberOfBytesToRead")) #log.i( "Read return Size: %d" % hc.read_dword(dbg, "lpNumberOfBytesRead")) size = hc.read_dword(dbg, "lpNumberOfBytesRead") info = ReadFileEvent(dbg.pid, dbg.tid, size = size, data = hc.read_data(dbg, "lpBuffer", size)) info.save() log.i(info.brief_info(),dbg)
def RegSetValueEx_entry_hook(hc, dbg):
info = RegSetEvent(dbg.pid,
dbg.tid,
h_key=_h_key(hc.args["hKey"]),
name=hc.read_string_auto(dbg, "lpValueName"),
size=hc.args["cbData"],
data=hc.read_string_auto(dbg, "lpData"))
info.save()
log.i(info.brief_info(), dbg)
def CreateProcess_exit_hook(hc, dbg): info = CreateProcessEvent(dbg.pid, dbg.tid, exe = hc.read_string_auto(dbg,"lpApplicationName"), cmd = hc.read_string_auto(dbg, "lpCommandLine"), env = hc.read_string_auto(dbg, "lpEnvironment"), cur_dir = hc.read_string_auto(dbg, "lpCurrentDirectory")) info.save() log.i(info.brief_info(),dbg)
def __delete_item(self, id):
# SQL 查询语句
sql = "DELETE FROM proxy WHERE id='%s'" % (id)
try:
# 执行SQL语句
self.__cursor.execute(sql)
self.__db.commit()
except Exception as e:
log.i('删除数据异常', e)
self.__db.rollback()
def RegQueryValueEx_exit_hook(hc, dbg): size = hc.read_dword(dbg, "lpcbData") info = RegQueryEvent(dbg.pid, dbg.tid, h_key = _h_key(hc.args["hKey"]), name = hc.read_string_auto(dbg, "lpValueName"), size = size, data = hc.read_data(dbg,"lpData", size)) info.save() log.i(info.brief_info(),dbg)
def compute_commands(self, gs):
"""
This is the main function that computes moves for every bot in a turn.
Global variable sharing has already been taken care of in robot.py. The
parameter gs is a GameState object, defined in game_state.py. Commands
are issued to each bot by calling bot.set_command(cmd) before each turn is
over. Some helpful constants can be found in const.py.
"""
log.i("Computing commands for turn " + str(gs.turn))
for bot in gs.friends:
bot.set_command(const.CMD_GUARD)
def popUID():
try:
#如果异常，抛出psycopg2.OperationalError;如果正常，连接将保持，pgsql无法从supervisor关闭;
pgsql=psycopg2.connect("dbname=rongoman user=postgres port=8004")
#不管连接是否被关闭，这里都不会异常
pgcur=pgsql.cursor()
#op恒等于None; 如果连接被强行关闭，这里抛出psycopg2.OperationalError
op = pgcur.execute("SELECT nextval ('seq_userid')")
#不管连接是否被关闭，这里都不会异常，但是会得到res的错误数据
res=pgcur.fetchone()
return res[0]
except Exception as e:
log.i(e);
return None
def WSASend_entry_hook(hc, dbg): buf_count = hc.args["dwBufferCount"] length = 0 data = "" for i in xrange(buf_count): wsabuf_p = hc.args["lpBuffers"] + i*8 # sizeof(WSABUF) buf_size = hc.read_dword(dbg, wsabuf_p) buf_p = hc.read_dword(dbg, wsabuf_p+4) buf_data = hc.read_data(dbg, buf_p, buf_size) length += buf_size data += buf_data info = WSASocketSendEvent(dbg.pid, dbg.tid, length = length, data = data) info.save() log.i(info.brief_info(), dbg)
def gen_report(self):
log.i("Generating report...")
print ""
text = header_h("Debug Infomation")
total = len(self.dbg_infos)
count = 0
for info in self.dbg_infos:
text+= info.to_html()
count+=1
sys.stdout.write("\rProcessing %d %%..." % (count * 100 /total))
sys.stdout.flush()
text = report_html(self._make_side_bar(), text)
self.write(text)
print ""
log.i("Report generating finished!")
def main():
addr, port = '127.0.0.1', 8080
if len(sys.argv) > 1 :
addr, port = parse_args()
log.d("addr: {}:{}".format(addr, port))
s = socket(AF_INET, SOCK_STREAM)
s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
try:
s.bind((addr, port))
s.listen(10)
while 1:
global lis
conn,addr = s.accept()
log.i("connected by {}".format(addr))
thread.start_new_thread(switch_handler, (s, conn, addr))
finally:
s.close()
def get( self ) :
try:
vid = self.get_argument( 'vid', default=None )
log.i('vid=%s' % vid)
domain = util.get_domain_from_host( self.request.host )
#reset = data_user.get_reset( mongo.db_pool[domain].reset, vid )
reset = NOne
if not reset:
log.w('no such reset pwd')
return self.redirect( etc.url['user_main'] )
else:
log.i( 'verify success' )
return self.render( "user_reset_pwd.html",
p_url = etc.url,
p_session = self.ss_data,
p_pwsecret = etc.pw_secret,
p_next = None,
p_email = reset['email'],
p_vid = reset['vid'],
)
except Exception as e :
log.exp( e )
self.redirect( etc.url['user_main'] )
def analyze(self):
log.i("analize: conversion count=%d", len(self.conversions))
total_ap = 0.0
total_mp = 0.0
for conv in self.conversions:
total_ap += conv.ap
total_mp += conv.mp*conv.rate/10.0
log.i("a: %.1f", total_ap)
log.i("m: %.1f", total_mp)
def Process( handler, *args ) :
#请求前重建Session数据的过程
try :
email = handler.get_argument( 'email',default=None )
passwd = handler.get_argument( 'passwd',default=None )
rememberme = handler.get_argument( 'rememberme',default=None )
log.i( 'email=%s , passwd=%s , rememberme=%s' % (email,passwd,rememberme) )
expires = None
if rememberme == "on" :
expires = datetime.datetime.utcnow() + datetime.timedelta(days=365)
if not email or not passwd:
log.w( 'empty email or passwd' )
res = { 'op':False, 'msg':'邮箱和密码不能为空' }
handler.write( json.dumps(res) )
handler.finish()
return
email = email.strip().lower()
domain = util.get_domain_from_host( handler.request.host )
#user = data_user.get_user_by_email( mongo.db_pool[domain].user, email, passwd )
user = None
handler.ss_id = None
if not user:
log.w( 'no such user' )
res = { 'op':False, 'msg':'邮箱或密码错误' }
handler.write( json.dumps(res) )
handler.finish()
return
if passwd != user['pw'] :
log.w( 'passwd err'+' '+ user['pw'] )
res = { 'op':False, 'msg':'邮箱或密码错误' }
handler.write( json.dumps(res) )
handler.finish()
return
if user['ss']['ssid'] :
old_ss_id = str( user['ss']['ssid'] )
old_ss_data = handler.ss_store.get( old_ss_id )
if old_ss_data :
log.i( "old session : uid=%s , ssid=%s" % (user['uid'],old_ss_id) )
handler.ss_id = old_ss_id
if not handler.ss_id :
handler.ss_id = generate_id()
log.i( "new session : uid=%s , ssid=%s" % (user['uid'],handler.ss_id) )
handler.ss_id_hmac = generate_hmac( handler.ss_id )
handler.set_secure_cookie( etc.cookie_name, handler.ss_id, domain=domain, expires=expires )
handler.set_secure_cookie( etc.cookie_verify, handler.ss_id_hmac, domain=domain, expires=expires )
#data_user.set_login( mongo.db_pool[domain].user, user['uid'], handler.ss_id )
handler.ss_user = user
#执行原本请求的方法
request( handler, *args )
except Exception as e :
log.exp(e)
res = { 'op':False, 'msg':etc.err_500 }
handler.write( json.dumps(res) )
handler.finish()
return
def get_current_user( self ) :
try:
uuid = self.get_cookie( etc.cookie_uuid )
if not uuid :
log.i( 'no uuid' )
expires = datetime.datetime.utcnow() + datetime.timedelta(days=365)
uuid = generate_uuid()
domain = util.get_domain_from_host( self.request.host )
self.set_cookie( etc.cookie_uuid, uuid, domain=domain, expires=expires )
self.uuid = uuid
usr_ss_id = self.get_secure_cookie( etc.cookie_name )
usr_ss_id_hmac = self.get_secure_cookie( etc.cookie_verify )
if not usr_ss_id or not usr_ss_id_hmac :
log.i( 'no cookie' )
self.clear_cookie( etc.cookie_name )
self.clear_cookie( etc.cookie_verify )
self.ss_data = None
return None
check_hmac = session_base.generate_hmac( usr_ss_id )
if usr_ss_id_hmac != check_hmac :
log.w("evil session : %s %s"%(usr_ss_id,usr_ss_id_hmac))
self.clear_cookie( etc.cookie_name )
self.clear_cookie( etc.cookie_verify )
self.ss_data = None
return None
old_ss_data = self.ss_store.get( usr_ss_id )
if old_ss_data == None :
log.i("session expired")
self.clear_cookie( etc.cookie_name )
self.clear_cookie( etc.cookie_verify )
self.ss_data = None
return None
self.ss_data = old_ss_data
return self.ss_data
except Exception as e :
log.exp(e)
self.clear_cookie( etc.cookie_name )
self.clear_cookie( etc.cookie_verify )
self.ss_data = None
return self.ss_data
#!/usr/bin/python
# coding=utf8
from flask import Flask
from flask_peewee.db import Database
app = Flask(__name__)
import log
app.config.from_object('config.LocalConfiguration')
app.config['DEBUG'] = True
log.i('Configuração de Banco de Dados:'+str(app.config['DATABASE']))
db = Database(app)
from api import *
def handler_create_process(dbg):
log.i("New process.. ", dbg)
info = CreateProcessInfo(dbg.pid, dbg.tid)
info.save()
return DBG_CONTINUE
def handler_exit_process(dbg):
log.i("Exit process.. ", dbg)
info = ExitProcessInfo(dbg.pid, dbg.tid)
info.save()
return DBG_CONTINUE
def handler_access_violation(dbg):
log.i("[!] Access violation.", dbg)
return DBG_EXCEPTION_NOT_HANDLED
def post( self ) :
log.i( '503' )
res = { 'op':False, 'msg':'无此功能' }
self.write( json.dumps(res) )
self.finish()
def close(self):
self.conn.close()
log.i('Disconnect with:' + str(self.addr))
def send_entry_hook(hc, dbg): info = SocketSendEvent(dbg.pid, dbg.tid, length=hc.args["len"], data = hc.read_data(dbg, "buf", "len")) info.save() log.i(info.brief_info(), dbg)
def WinHttpConnect_entry_hook(hc, dbg):
info = HTTPConnectEvent(dbg.pid, dbg.tid,
server= hc.read_string_auto(dbg, "pswzServerName"),
port = hc.get_value("nServerPort") )
info.save()
log.i(info.brief_info(), dbg)
def CreateFile_entry_hook(hc, dbg): info = CreateFileEvent(dbg.pid, dbg.tid, path =hc.read_string_auto(dbg, "lpFileName") ) info.save() log.i(info.brief_info(), dbg)
