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)