idx
int64 0
63k
| question
stringlengths 61
4.03k
| target
stringlengths 6
1.23k
|
|---|---|---|
9,600
|
def mnemonic ( self , value ) : if value not in REIL_MNEMONICS : raise Exception ( "Invalid instruction mnemonic : %s" % str ( value ) ) self . _mnemonic = value
|
Set instruction mnemonic .
|
9,601
|
def operands ( self , value ) : if len ( value ) != 3 : raise Exception ( "Invalid instruction operands : %s" % str ( value ) ) self . _operands = value
|
Set instruction operands .
|
9,602
|
def __taint_load ( self , instr ) : op0_val = self . __emu . read_operand ( instr . operands [ 0 ] ) op0_taint = self . get_memory_taint ( op0_val , instr . operands [ 2 ] . size // 8 ) self . set_operand_taint ( instr . operands [ 2 ] , op0_taint )
|
Taint LDM instruction .
|
9,603
|
def __taint_store ( self , instr ) : op2_val = self . __emu . read_operand ( instr . operands [ 2 ] ) op0_size = instr . operands [ 0 ] . size op0_taint = self . get_operand_taint ( instr . operands [ 0 ] ) self . set_memory_taint ( op2_val , op0_size // 8 , op0_taint )
|
Taint STM instruction .
|
9,604
|
def __taint_move ( self , instr ) : op0_taint = self . get_operand_taint ( instr . operands [ 0 ] ) self . set_operand_taint ( instr . operands [ 2 ] , op0_taint )
|
Taint registers move instruction .
|
9,605
|
def execute ( self , asm_instr ) : self . ir_emulator . registers [ self . ip ] = asm_instr . address + asm_instr . size if self . arch_info . instr_is_syscall ( asm_instr ) : raise Syscall ( ) return self . __execute ( asm_instr )
|
Execute an assembler instruction .
|
9,606
|
def ir_instrs ( self ) : ir_instrs = [ ] for asm_instr in self . _instrs : ir_instrs += asm_instr . ir_instrs return ir_instrs
|
Get gadgets IR instructions .
|
9,607
|
def load_symbols_elf ( filename ) : f = open ( filename , 'rb' ) elffile = ELFFile ( f ) symbols = [ ] for section in elffile . iter_sections ( ) : if not isinstance ( section , SymbolTableSection ) : continue if section [ 'sh_entsize' ] == 0 : logger . warn ( "Symbol table {} has a sh_entsize of zero." . format ( section . name ) ) continue logger . info ( "Symbol table {} contains {} entries." . format ( section . name , section . num_symbols ( ) ) ) for _ , symbol in enumerate ( section . iter_symbols ( ) ) : if describe_symbol_shndx ( symbol [ 'st_shndx' ] ) != "UND" and describe_symbol_type ( symbol [ 'st_info' ] [ 'type' ] ) == "FUNC" : symbols . append ( ( symbol [ 'st_value' ] , symbol [ 'st_size' ] , symbol . name ) ) f . close ( ) symbols_by_addr = { addr : ( name , size , True ) for addr , size , name in symbols } return symbols_by_addr
|
Load the symbol tables contained in the file
|
9,608
|
def _classify_no_operation ( self , regs_init , regs_fini , mem_fini , written_regs , read_regs ) : matches = [ ] regs_changed = any ( regs_init [ r ] != regs_fini [ r ] for r in regs_init ) flags_changed = False mem_changed = mem_fini . get_write_count ( ) != 0 if not regs_changed and not flags_changed and not mem_changed : matches . append ( { "op" : "nop" , } ) return matches
|
Classify no - operation gadgets .
|
9,609
|
def _classify_move_register ( self , regs_init , regs_fini , mem_fini , written_regs , read_regs ) : matches = [ ] regs_init_inv = self . _invert_dictionary ( regs_init ) for dst_reg , dst_val in regs_fini . items ( ) : if dst_reg not in written_regs : continue for src_reg in regs_init_inv . get ( dst_val , [ ] ) : if src_reg not in read_regs : continue if self . _arch_regs_size [ src_reg ] != self . _arch_regs_size [ dst_reg ] : continue if src_reg == dst_reg : continue if regs_init [ dst_reg ] == regs_init [ src_reg ] : continue src_reg_ir = ReilRegisterOperand ( src_reg , self . _arch_regs_size [ src_reg ] ) dst_reg_ir = ReilRegisterOperand ( dst_reg , self . _arch_regs_size [ dst_reg ] ) matches . append ( { "src" : [ src_reg_ir ] , "dst" : [ dst_reg_ir ] } ) return matches
|
Classify move - register gadgets .
|
9,610
|
def _classify_load_constant ( self , regs_init , regs_fini , mem_fini , written_regs , read_regs ) : matches = [ ] for dst_reg , dst_val in regs_fini . items ( ) : if dst_reg not in written_regs : continue if dst_val == regs_init [ dst_reg ] : continue dst_val_ir = ReilImmediateOperand ( dst_val , self . _arch_regs_size [ dst_reg ] ) dst_reg_ir = ReilRegisterOperand ( dst_reg , self . _arch_regs_size [ dst_reg ] ) matches . append ( { "src" : [ dst_val_ir ] , "dst" : [ dst_reg_ir ] } ) return matches
|
Classify load - constant gadgets .
|
9,611
|
def _classify_arithmetic ( self , regs_init , regs_fini , mem_fini , written_regs , read_regs ) : matches = [ ] op_restrictions = { "+" : lambda x , y : False , "-" : lambda x , y : x == y , "|" : lambda x , y : x == y , "&" : lambda x , y : x == y , "^" : lambda x , y : x == y , } for op_name , op_fn in self . _binary_ops . items ( ) : for src_1_reg , src_1_val in regs_init . items ( ) : if src_1_reg not in read_regs : continue for src_2_reg , src_2_val in regs_init . items ( ) : if src_2_reg not in read_regs : continue for dst_reg , dst_val in regs_fini . items ( ) : if dst_reg not in written_regs : continue if self . _arch_regs_size [ src_1_reg ] != self . _arch_regs_size [ src_2_reg ] or self . _arch_regs_size [ src_1_reg ] != self . _arch_regs_size [ dst_reg ] : continue if op_restrictions [ op_name ] ( src_1_reg , src_2_reg ) : continue size = self . _arch_regs_size [ src_1_reg ] if dst_val == op_fn ( src_1_val , src_2_val ) & ( 2 ** size - 1 ) : src = sorted ( [ src_1_reg , src_2_reg ] ) src_ir = [ ReilRegisterOperand ( src [ 0 ] , self . _arch_regs_size [ src [ 0 ] ] ) , ReilRegisterOperand ( src [ 1 ] , self . _arch_regs_size [ src [ 1 ] ] ) ] dst_reg_ir = ReilRegisterOperand ( dst_reg , self . _arch_regs_size [ dst_reg ] ) matches . append ( { "src" : src_ir , "dst" : [ dst_reg_ir ] , "op" : op_name } ) return matches
|
Classify binary - operation gadgets .
|
9,612
|
def _classify_load_memory ( self , regs_init , regs_fini , mem_fini , written_regs , read_regs ) : matches = [ ] regs_init_inv = self . _invert_dictionary ( regs_init ) for dst_reg , dst_val in regs_fini . items ( ) : if dst_reg not in written_regs : continue dst_size = self . _arch_regs_size [ dst_reg ] for src_addr in mem_fini . read_inverse ( dst_val , dst_size // 8 ) : for src_reg , src_val in regs_init . items ( ) : if src_reg not in read_regs : continue if self . _arch_regs_size [ src_reg ] != self . _address_size : continue offset = ( src_addr - src_val ) & ( 2 ** self . _address_size - 1 ) src_reg_ir = ReilRegisterOperand ( src_reg , self . _arch_regs_size [ src_reg ] ) src_off_ir = ReilImmediateOperand ( offset , self . _arch_regs_size [ src_reg ] ) dst_reg_ir = ReilRegisterOperand ( dst_reg , self . _arch_regs_size [ dst_reg ] ) matches . append ( { "src" : [ src_reg_ir , src_off_ir ] , "dst" : [ dst_reg_ir ] } ) for dst_reg , dst_val in regs_fini . items ( ) : if dst_reg not in written_regs : continue dst_size = self . _arch_regs_size [ dst_reg ] for src_addr in mem_fini . read_inverse ( dst_val , dst_size // 8 ) : src_reg_ir = ReilEmptyOperand ( ) src_off_ir = ReilImmediateOperand ( src_addr , self . _address_size ) dst_reg_ir = ReilRegisterOperand ( dst_reg , self . _arch_regs_size [ dst_reg ] ) matches . append ( { "src" : [ src_reg_ir , src_off_ir ] , "dst" : [ dst_reg_ir ] } ) return matches
|
Classify load - memory gadgets .
|
9,613
|
def _classify_store_memory ( self , regs_init , regs_fini , mem_fini , written_regs , read_regs ) : matches = [ ] regs_init_inv = self . _invert_dictionary ( regs_init ) for src_reg , src_val in regs_init . items ( ) : if src_reg not in read_regs : continue src_size = self . _arch_regs_size [ src_reg ] for addr in mem_fini . read_inverse ( src_val , src_size // 8 ) : for dst_reg , dst_val in regs_init . items ( ) : if dst_reg not in read_regs : continue if self . _arch_regs_size [ dst_reg ] != self . _address_size : continue offset = ( addr - dst_val ) & ( 2 ** self . _address_size - 1 ) src_reg_ir = ReilRegisterOperand ( src_reg , self . _arch_regs_size [ src_reg ] ) dst_reg_ir = ReilRegisterOperand ( dst_reg , self . _arch_regs_size [ dst_reg ] ) dst_off_ir = ReilImmediateOperand ( offset , self . _arch_regs_size [ dst_reg ] ) matches . append ( { "src" : [ src_reg_ir ] , "dst" : [ dst_reg_ir , dst_off_ir ] } ) for src_reg , src_val in regs_init . items ( ) : if src_reg not in read_regs : continue src_size = self . _arch_regs_size [ src_reg ] for addr in mem_fini . read_inverse ( src_val , src_size // 8 ) : offset = addr & ( 2 ** self . _address_size - 1 ) src_reg_ir = ReilRegisterOperand ( src_reg , self . _arch_regs_size [ src_reg ] ) dst_reg_ir = ReilEmptyOperand ( ) dst_off_ir = ReilImmediateOperand ( offset , self . _address_size ) matches . append ( { "src" : [ src_reg_ir ] , "dst" : [ dst_reg_ir , dst_off_ir ] } ) return matches
|
Classify store - memory gadgets .
|
9,614
|
def _classify_arithmetic_load ( self , regs_init , regs_fini , mem_fini , written_regs , read_regs ) : matches = [ ] for op_name , op_fn in self . _binary_ops . items ( ) : for dst_reg , dst_val in regs_fini . items ( ) : if dst_reg not in written_regs or dst_reg not in read_regs : continue dst_size = self . _arch_regs_size [ dst_reg ] for addr in mem_fini . get_addresses ( ) : success , val = mem_fini . try_read ( addr , dst_size // 8 ) if success and dst_val == op_fn ( regs_init [ dst_reg ] , val ) & ( 2 ** dst_size - 1 ) : for src_reg , src_val in regs_init . items ( ) : if src_reg not in read_regs : continue if self . _arch_regs_size [ src_reg ] != self . _address_size : continue offset = ( addr - src_val ) & ( 2 ** self . _address_size - 1 ) src_reg_ir = ReilRegisterOperand ( src_reg , self . _arch_regs_size [ src_reg ] ) src_off_ir = ReilImmediateOperand ( offset , self . _address_size ) dst_reg_ir = ReilRegisterOperand ( dst_reg , self . _arch_regs_size [ dst_reg ] ) matches . append ( { "src" : [ dst_reg_ir , src_reg_ir , src_off_ir ] , "dst" : [ dst_reg_ir ] , "op" : op_name } ) for op_name , op_fn in self . _binary_ops . items ( ) : for dst_reg , dst_val in regs_fini . items ( ) : if dst_reg not in written_regs or dst_reg not in read_regs : continue dst_size = self . _arch_regs_size [ dst_reg ] for addr in mem_fini . get_addresses ( ) : success , val = mem_fini . try_read ( addr , dst_size // 8 ) if success and dst_val == op_fn ( regs_init [ dst_reg ] , val ) & ( 2 ** dst_size - 1 ) : src_reg_ir = ReilEmptyOperand ( ) src_off_ir = ReilImmediateOperand ( addr , self . _address_size ) dst_reg_ir = ReilRegisterOperand ( dst_reg , self . _arch_regs_size [ dst_reg ] ) matches . append ( { "src" : [ dst_reg_ir , src_reg_ir , src_off_ir ] , "dst" : [ dst_reg_ir ] , "op" : op_name } ) return matches
|
Classify arithmetic - load gadgets .
|
9,615
|
def _classify_arithmetic_store ( self , regs_init , regs_fini , mem_fini , written_regs , read_regs ) : matches = [ ] for op_name , op_fn in self . _binary_ops . items ( ) : for size in [ 8 , 16 , 32 , 64 ] : for addr in mem_fini . get_addresses ( ) : success_read_curr , val_curr = mem_fini . try_read ( addr , size // 8 ) success_read_prev , val_prev = mem_fini . try_read_prev ( addr , size // 8 ) if success_read_curr and success_read_prev : for src_reg , src_val in regs_init . items ( ) : if src_reg not in read_regs : continue if self . _arch_regs_size [ src_reg ] != size : continue if val_curr == op_fn ( src_val , val_prev ) & ( 2 ** size - 1 ) : for dst_reg , dst_val in regs_init . items ( ) : if dst_reg not in read_regs : continue if self . _arch_regs_size [ dst_reg ] != self . _address_size : continue offset = ( addr - dst_val ) & ( 2 ** self . _address_size - 1 ) src_reg_ir = ReilRegisterOperand ( src_reg , self . _arch_regs_size [ src_reg ] ) dst_reg_ir = ReilRegisterOperand ( dst_reg , self . _arch_regs_size [ dst_reg ] ) dst_off_ir = ReilImmediateOperand ( offset , self . _address_size ) matches . append ( { "src" : [ dst_reg_ir , dst_off_ir , src_reg_ir ] , "dst" : [ dst_reg_ir , dst_off_ir ] , "op" : op_name } ) for op_name , op_fn in self . _binary_ops . items ( ) : for size in [ 8 , 16 , 32 , 64 ] : for addr in mem_fini . get_addresses ( ) : success_read_curr , val_curr = mem_fini . try_read ( addr , size // 8 ) success_read_prev , val_prev = mem_fini . try_read_prev ( addr , size // 8 ) if success_read_curr and success_read_prev : for src_reg , src_val in regs_init . items ( ) : if src_reg not in read_regs : continue if self . _arch_regs_size [ src_reg ] != size : continue if val_curr == op_fn ( src_val , val_prev ) & ( 2 ** size - 1 ) : src_reg_ir = ReilRegisterOperand ( src_reg , self . _arch_regs_size [ src_reg ] ) dst_reg_ir = ReilEmptyOperand ( ) dst_off_ir = ReilImmediateOperand ( addr , self . _address_size ) matches . append ( { "src" : [ dst_reg_ir , dst_off_ir , src_reg_ir ] , "dst" : [ dst_reg_ir , dst_off_ir ] , "op" : op_name } ) return matches
|
Classify arithmetic - store gadgets .
|
9,616
|
def _init_regs_random ( self ) : values = set ( ) while len ( values ) != len ( self . _arch_regs_parent ) : values . add ( random . randint ( 0 , 2 ** self . _arch_info . operand_size - 1 ) ) values = list ( values ) regs = { } for idx , reg in enumerate ( self . _arch_regs_parent ) : regs [ reg ] = values [ idx ] & ( 2 ** self . _arch_regs_size [ reg ] - 1 ) return regs
|
Initialize register with random values .
|
9,617
|
def _compute_mod_regs ( self , regs_init , regs_fini ) : assert regs_init . keys ( ) == regs_fini . keys ( ) modified_regs = [ ] for reg in regs_init : if regs_init [ reg ] != regs_fini [ reg ] : modified_regs . append ( reg ) return modified_regs
|
Compute modified registers .
|
9,618
|
def _invert_dictionary ( self , d ) : inv_dict = { } for k , v in d . items ( ) : inv_dict [ v ] = inv_dict . get ( v , [ ] ) inv_dict [ v ] += [ k ] return inv_dict
|
Invert a dictionary .
|
9,619
|
def _print_memory ( self , memory ) : for addr , value in memory . items ( ) : print ( " 0x%08x : 0x%08x (%d)" % ( addr , value , value ) )
|
Print memory .
|
9,620
|
def _print_registers ( self , registers ) : for reg , value in registers . items ( ) : print ( " %s : 0x%08x (%d)" % ( reg , value , value ) )
|
Print registers .
|
9,621
|
def bb_get_instr_max_width ( basic_block ) : asm_mnemonic_max_width = 0 for instr in basic_block : if len ( instr . mnemonic ) > asm_mnemonic_max_width : asm_mnemonic_max_width = len ( instr . mnemonic ) return asm_mnemonic_max_width
|
Get maximum instruction mnemonic width
|
9,622
|
def end_address ( self ) : if self . _instrs is [ ] : return None return self . _instrs [ - 1 ] . address + self . _instrs [ - 1 ] . size - 1
|
Get basic block end address .
|
9,623
|
def size ( self ) : if self . _instrs is [ ] : return None return sum ( [ instr . size for instr in self . _instrs ] )
|
Get basic block size .
|
9,624
|
def branches ( self ) : branches = [ ] if self . _taken_branch : branches += [ ( self . _taken_branch , 'taken' ) ] if self . _not_taken_branch : branches += [ ( self . _not_taken_branch , 'not-taken' ) ] if self . _direct_branch : branches += [ ( self . _direct_branch , 'direct' ) ] return branches
|
Get basic block branches .
|
9,625
|
def _compute_register_list ( self , operand ) : ret = [ ] for reg_range in operand . reg_list : if len ( reg_range ) == 1 : ret . append ( ReilRegisterOperand ( reg_range [ 0 ] . name , reg_range [ 0 ] . size ) ) else : reg_num = int ( reg_range [ 0 ] . name [ 1 : ] ) reg_end = int ( reg_range [ 1 ] . name [ 1 : ] ) if reg_num > reg_end : raise NotImplementedError ( "Instruction Not Implemented: Invalid register range." ) while reg_num <= reg_end : ret . append ( ReilRegisterOperand ( reg_range [ 0 ] . name [ 0 ] + str ( reg_num ) , reg_range [ 0 ] . size ) ) reg_num = reg_num + 1 return ret
|
Return operand register list .
|
9,626
|
def translate ( self , instruction ) : try : trans_instrs = self . __translate ( instruction ) except NotImplementedError : unkn_instr = self . _builder . gen_unkn ( ) unkn_instr . address = instruction . address << 8 | ( 0x0 & 0xff ) trans_instrs = [ unkn_instr ] self . _log_not_supported_instruction ( instruction ) except Exception : self . _log_translation_exception ( instruction ) raise return trans_instrs
|
Return IR representation of an instruction .
|
9,627
|
def read ( self , address , size ) : value = 0x0 for i in range ( 0 , size ) : value |= self . _read_byte ( address + i ) << ( i * 8 ) return value
|
Read arbitrary size content from memory .
|
9,628
|
def _read_byte ( self , address ) : if address not in self . _memory : self . _memory [ address ] = random . randint ( 0x00 , 0xff ) return self . _memory [ address ]
|
Read a byte from memory .
|
9,629
|
def write ( self , address , size , value ) : for i in range ( 0 , size ) : self . __write_byte ( address + i , ( value >> ( i * 8 ) ) & 0xff )
|
Write arbitrary size content to memory .
|
9,630
|
def read_inverse ( self , value , size ) : addr_candidates = [ addr for addr , val in self . _memory . items ( ) if val == ( value & 0xff ) ] addr_matches = [ ] for addr in addr_candidates : match = True for i in range ( 0 , size ) : byte_curr = ( value >> ( i * 8 ) ) & 0xff try : match = self . _memory [ addr + i ] == byte_curr except KeyError : match = False if not match : break if match : addr_matches += [ addr ] return addr_matches
|
Return a list of memory addresses that contain the specified value .
|
9,631
|
def try_read ( self , address , size ) : value = 0x0 for i in range ( 0 , size ) : addr = address + i if addr in self . _memory : value |= self . _read_byte ( addr ) << ( i * 8 ) else : return False , None return True , value
|
Try to read memory content at specified address .
|
9,632
|
def try_read_prev ( self , address , size ) : value = 0x0 for i in range ( 0 , size ) : addr = address + i if addr in self . __memory_prev : _ , val_byte = self . __try_read_byte_prev ( addr ) value |= val_byte << ( i * 8 ) else : return False , None return True , value
|
Try to read previous memory content at specified address .
|
9,633
|
def __try_read_byte_prev ( self , address ) : if address not in self . __memory_prev : return False , None return True , self . __memory_prev [ address ]
|
Read previous value for memory location .
|
9,634
|
def __write_byte ( self , address , value ) : if address in self . _memory : self . __memory_prev [ address ] = self . _memory [ address ] self . _memory [ address ] = value & 0xff
|
Write byte in memory .
|
9,635
|
def gen_add ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . ADD , src1 , src2 , dst )
|
Return an ADD instruction .
|
9,636
|
def gen_sub ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . SUB , src1 , src2 , dst )
|
Return a SUB instruction .
|
9,637
|
def gen_mul ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . MUL , src1 , src2 , dst )
|
Return a MUL instruction .
|
9,638
|
def gen_div ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . DIV , src1 , src2 , dst )
|
Return a DIV instruction .
|
9,639
|
def gen_mod ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . MOD , src1 , src2 , dst )
|
Return a MOD instruction .
|
9,640
|
def gen_bsh ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . BSH , src1 , src2 , dst )
|
Return a BSH instruction .
|
9,641
|
def gen_and ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . AND , src1 , src2 , dst )
|
Return an AND instruction .
|
9,642
|
def gen_or ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . OR , src1 , src2 , dst )
|
Return an OR instruction .
|
9,643
|
def gen_xor ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . XOR , src1 , src2 , dst )
|
Return a XOR instruction .
|
9,644
|
def gen_ldm ( src , dst ) : return ReilBuilder . build ( ReilMnemonic . LDM , src , ReilEmptyOperand ( ) , dst )
|
Return a LDM instruction .
|
9,645
|
def gen_stm ( src , dst ) : return ReilBuilder . build ( ReilMnemonic . STM , src , ReilEmptyOperand ( ) , dst )
|
Return a STM instruction .
|
9,646
|
def gen_str ( src , dst ) : return ReilBuilder . build ( ReilMnemonic . STR , src , ReilEmptyOperand ( ) , dst )
|
Return a STR instruction .
|
9,647
|
def gen_bisz ( src , dst ) : return ReilBuilder . build ( ReilMnemonic . BISZ , src , ReilEmptyOperand ( ) , dst )
|
Return a BISZ instruction .
|
9,648
|
def gen_jcc ( src , dst ) : return ReilBuilder . build ( ReilMnemonic . JCC , src , ReilEmptyOperand ( ) , dst )
|
Return a JCC instruction .
|
9,649
|
def gen_unkn ( ) : empty_reg = ReilEmptyOperand ( ) return ReilBuilder . build ( ReilMnemonic . UNKN , empty_reg , empty_reg , empty_reg )
|
Return an UNKN instruction .
|
9,650
|
def gen_undef ( ) : empty_reg = ReilEmptyOperand ( ) return ReilBuilder . build ( ReilMnemonic . UNDEF , empty_reg , empty_reg , empty_reg )
|
Return an UNDEF instruction .
|
9,651
|
def gen_nop ( ) : empty_reg = ReilEmptyOperand ( ) return ReilBuilder . build ( ReilMnemonic . NOP , empty_reg , empty_reg , empty_reg )
|
Return a NOP instruction .
|
9,652
|
def gen_sext ( src , dst ) : assert src . size <= dst . size empty_reg = ReilEmptyOperand ( ) return ReilBuilder . build ( ReilMnemonic . SEXT , src , empty_reg , dst )
|
Return a SEXT instruction .
|
9,653
|
def gen_sdiv ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . SDIV , src1 , src2 , dst )
|
Return a SDIV instruction .
|
9,654
|
def gen_smod ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . SMOD , src1 , src2 , dst )
|
Return a SMOD instruction .
|
9,655
|
def gen_smul ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . SMUL , src1 , src2 , dst )
|
Return a SMUL instruction .
|
9,656
|
def build ( mnemonic , oprnd1 , oprnd2 , oprnd3 ) : ins = ReilInstruction ( ) ins . mnemonic = mnemonic ins . operands = [ oprnd1 , oprnd2 , oprnd3 ] return ins
|
Return the specified instruction .
|
9,657
|
def _setup_arch ( self , arch_mode = None ) : self . arch_info = None if self . binary . architecture == ARCH_X86 : self . _setup_x86_arch ( arch_mode ) else : self . _setup_arm_arch ( arch_mode )
|
Set up architecture .
|
9,658
|
def _setup_arm_arch ( self , arch_mode = None ) : if arch_mode is None : arch_mode = ARCH_ARM_MODE_THUMB self . name = "ARM" self . arch_info = ArmArchitectureInformation ( arch_mode ) self . disassembler = ArmDisassembler ( architecture_mode = arch_mode ) self . ir_translator = ArmTranslator ( architecture_mode = arch_mode )
|
Set up ARM architecture .
|
9,659
|
def _setup_x86_arch ( self , arch_mode = None ) : if arch_mode is None : arch_mode = self . binary . architecture_mode self . name = "x86" self . arch_info = X86ArchitectureInformation ( arch_mode ) self . disassembler = X86Disassembler ( arch_mode ) self . ir_translator = X86Translator ( arch_mode )
|
Set up x86 architecture .
|
9,660
|
def _setup_core_modules ( self ) : self . ir_emulator = None self . smt_solver = None self . smt_translator = None if self . arch_info : self . ir_emulator = ReilEmulator ( self . arch_info ) self . smt_solver = None if SMT_SOLVER not in ( "Z3" , "CVC4" ) : raise Exception ( "{} SMT solver not supported." . format ( SMT_SOLVER ) ) try : if SMT_SOLVER == "Z3" : self . smt_solver = Z3Solver ( ) elif SMT_SOLVER == "CVC4" : self . smt_solver = CVC4Solver ( ) except SmtSolverNotFound : logger . warn ( "{} Solver is not installed. Run 'barf-install-solvers.sh' to install it." . format ( SMT_SOLVER ) ) self . smt_translator = None if self . smt_solver : self . smt_translator = SmtTranslator ( self . smt_solver , self . arch_info . address_size ) self . smt_translator . set_arch_alias_mapper ( self . arch_info . alias_mapper ) self . smt_translator . set_arch_registers_size ( self . arch_info . registers_size )
|
Set up core modules .
|
9,661
|
def _setup_analysis_modules ( self ) : self . bb_builder = CFGRecoverer ( RecursiveDescent ( self . disassembler , self . text_section , self . ir_translator , self . arch_info ) ) self . code_analyzer = None if self . smt_translator : self . code_analyzer = CodeAnalyzer ( self . smt_solver , self . smt_translator , self . arch_info ) self . gadget_classifier = GadgetClassifier ( self . ir_emulator , self . arch_info ) self . gadget_finder = GadgetFinder ( self . disassembler , self . text_section , self . ir_translator , self . binary . architecture , self . binary . architecture_mode ) self . gadget_verifier = None if self . code_analyzer : self . gadget_verifier = GadgetVerifier ( self . code_analyzer , self . arch_info ) self . emulator = Emulator ( self . arch_info , self . ir_emulator , self . ir_translator , self . disassembler )
|
Set up analysis modules .
|
9,662
|
def open ( self , filename ) : if filename : self . binary = BinaryFile ( filename ) self . text_section = self . binary . text_section self . _load ( arch_mode = self . binary . architecture_mode )
|
Open a file for analysis .
|
9,663
|
def disassemble ( self , start = None , end = None , arch_mode = None ) : if arch_mode is None : arch_mode = self . binary . architecture_mode curr_addr = start if start else self . binary . ea_start end_addr = end if end else self . binary . ea_end while curr_addr < end_addr : encoding = self . __fetch_instr ( curr_addr ) asm_instr = self . disassembler . disassemble ( encoding , curr_addr , architecture_mode = arch_mode ) if not asm_instr : return yield curr_addr , asm_instr , asm_instr . size curr_addr += asm_instr . size
|
Disassemble native instructions .
|
9,664
|
def recover_cfg ( self , start = None , end = None , symbols = None , callback = None , arch_mode = None ) : if arch_mode is None : arch_mode = self . binary . architecture_mode self . _load ( arch_mode = arch_mode ) start = start if start else self . binary . entry_point cfg , _ = self . _recover_cfg ( start = start , end = end , symbols = symbols , callback = callback ) return cfg
|
Recover CFG .
|
9,665
|
def emulate ( self , context = None , start = None , end = None , arch_mode = None , hooks = None , max_instrs = None , print_asm = False ) : if arch_mode is not None : self . _load ( arch_mode = arch_mode ) context = context if context else { } start_addr = start if start else self . binary . ea_start end_addr = end if end else self . binary . ea_end hooks = hooks if hooks else { } for reg , val in context . get ( 'registers' , { } ) . items ( ) : self . ir_emulator . registers [ reg ] = val for addr , val in context . get ( 'memory' , { } ) . items ( ) : self . ir_emulator . memory . write ( addr , 4 , val ) self . emulator . emulate ( start_addr , end_addr , hooks , max_instrs , print_asm ) context_out = { 'registers' : { } , 'memory' : { } } for reg , val in self . ir_emulator . registers . items ( ) : context_out [ 'registers' ] [ reg ] = val return context_out
|
Emulate native code .
|
9,666
|
def find ( self , start_address , end_address , byte_depth = 20 , instrs_depth = 2 ) : self . _max_bytes = byte_depth self . _instrs_depth = instrs_depth if self . _architecture == ARCH_X86 : candidates = self . _find_x86_candidates ( start_address , end_address ) elif self . _architecture == ARCH_ARM : candidates = self . _find_arm_candidates ( start_address , end_address ) else : raise Exception ( "Architecture not supported." ) return sorted ( candidates , key = lambda g : g . address )
|
Find gadgets .
|
9,667
|
def _build_from ( self , address , root , base_address , depth = 2 ) : if depth == 0 : return end_addr = address for step in range ( 1 , self . _max_bytes + 1 ) : start_addr = address - step if start_addr < 0 or start_addr < base_address : break raw_bytes = self . _mem [ start_addr : end_addr ] if self . _architecture == ARCH_ARM : try : asm_instr = self . _disasm . disassemble ( raw_bytes , start_addr , architecture_mode = self . _architecture_mode ) except InvalidDisassemblerData : continue else : try : asm_instr = self . _disasm . disassemble ( raw_bytes , start_addr ) except : asm_instr = None if not asm_instr or asm_instr . size != step : continue try : ir_instrs = self . _ir_trans . translate ( asm_instr ) except : continue if self . _is_valid_ins ( ir_instrs ) : asm_instr . ir_instrs = ir_instrs child = GadgetTreeNode ( asm_instr ) root . add_child ( child ) self . _build_from ( address - step , child , base_address , depth - 1 )
|
Build gadgets recursively .
|
9,668
|
def _build_gadgets ( self , gadget_tree_root ) : node_list = self . _build_gadgets_rec ( gadget_tree_root ) return [ RawGadget ( n ) for n in node_list ]
|
Return a gadgets list .
|
9,669
|
def _build_gadgets_rec ( self , gadget_tree_root ) : root = gadget_tree_root . get_root ( ) children = gadget_tree_root . get_children ( ) node_list = [ ] root_gadget_ins = root if not children : node_list += [ [ root_gadget_ins ] ] else : for child in children : node_list_rec = self . _build_gadgets_rec ( child ) node_list += [ n + [ root_gadget_ins ] for n in node_list_rec ] return node_list
|
Build a gadgets from a gadgets tree .
|
9,670
|
def _is_valid_ins ( self , ins_ir ) : invalid_instrs = [ ReilMnemonic . JCC , ReilMnemonic . UNDEF , ReilMnemonic . UNKN , ] return not any ( [ i . mnemonic in invalid_instrs for i in ins_ir ] )
|
Check for instruction validity as a gadgets .
|
9,671
|
def translate ( self , instruction ) : try : trans_instrs = self . _translate ( instruction ) except Exception : self . _log_translation_exception ( instruction ) raise TranslationError ( "Unknown error" ) return trans_instrs
|
Return REIL representation of an instruction .
|
9,672
|
def add_instruction ( self , reil_instruction ) : for expr in self . _translator . translate ( reil_instruction ) : self . _solver . add ( expr )
|
Add an instruction for analysis .
|
9,673
|
def _get_var_name ( self , register_name , mode ) : var_name = { "pre" : self . _translator . get_name_init ( register_name ) , "post" : self . _translator . get_name_curr ( register_name ) , } return var_name [ mode ]
|
Get variable name for a register considering pre and post mode .
|
9,674
|
def __process_instr ( self , instr , avoid , next_addr , initial_state , execution_state , trace_current ) : if instr . mnemonic == ReilMnemonic . JCC : not_taken_addr = next_addr address , index = split_address ( instr . address ) logger . debug ( "[+] Processing branch: {:#08x}:{:02x} : {}" . format ( address , index , instr ) ) if isinstance ( instr . operands [ 0 ] , ReilRegisterOperand ) : next_ip = self . __process_branch_cond ( instr , avoid , initial_state , execution_state , trace_current , not_taken_addr ) else : next_ip = self . __process_branch_uncond ( instr , trace_current , not_taken_addr ) else : trace_current += [ ( instr , None ) ] self . __cpu . execute ( instr ) next_ip = next_addr return next_ip
|
Process a REIL instruction .
|
9,675
|
def __fa_process_sequence ( self , sequence , avoid , initial_state , execution_state , trace_current , next_addr ) : ip = sequence . address next_ip = None while ip : try : instr = sequence . fetch ( ip ) except ReilSequenceInvalidAddressError : assert split_address ( ip ) [ 1 ] == 0x0 next_ip = ip break try : target_addr = sequence . get_next_address ( ip ) except ReilSequenceInvalidAddressError : target_addr = next_addr next_ip = self . __process_instr ( instr , avoid , target_addr , initial_state , execution_state , trace_current ) try : ip = next_ip if next_ip else sequence . get_next_address ( ip ) except ReilSequenceInvalidAddressError : break return next_ip
|
Process a REIL sequence .
|
9,676
|
def __fa_process_container ( self , container , find , start , end , avoid , initial_state , execution_state , trace_current , trace_final ) : ip = start while ip : try : instr = container . fetch ( ip ) except ReilContainerInvalidAddressError : logger . debug ( "Exception @ {:#08x}" . format ( ip ) ) raise ReilContainerInvalidAddressError try : next_addr = container . get_next_address ( ip ) except Exception : logger . debug ( "Exception @ {:#08x}" . format ( ip ) ) raise ReilContainerInvalidAddressError next_ip = self . __process_instr ( instr , avoid , next_addr , initial_state , execution_state , trace_current ) if find and next_ip and next_ip == find : logger . debug ( "[+] Find address found!" ) trace_final . append ( list ( trace_current ) ) next_ip = None if end and next_ip and next_ip == end : logger . debug ( "[+] End address found!" ) next_ip = None ip = next_ip if next_ip else None while not ip : if not execution_state . empty ( ) : ip , trace_current , registers , memory = execution_state . get ( ) if split_address ( ip ) [ 1 ] == 0x0 : logger . debug ( "[+] Popping execution state @ {:#x} (INTER)" . format ( ip ) ) else : logger . debug ( "[+] Popping execution state @ {:#x} (INTRA)" . format ( ip ) ) self . __cpu . registers = registers self . __cpu . memory = memory logger . debug ( "[+] Next address: {:#08x}:{:02x}" . format ( ip >> 8 , ip & 0xff ) ) else : logger . debug ( "[+] No more paths to explore! Exiting..." ) break if find and ip == find : logger . debug ( "[+] Find address found!" ) trace_final . append ( list ( trace_current ) ) ip = None if end and ip == end : logger . debug ( "[+] End address found!" ) ip = None
|
Process a REIL container .
|
9,677
|
def find_function_by_name ( self , name ) : cfg_rv = None for cfg in self . _cfgs : if cfg . name == name : cfg_rv = cfg break return cfg_rv
|
Return the cfg of the requested function by name .
|
9,678
|
def find_function_by_address ( self , address ) : cfg_rv = None for cfg in self . _cfgs : if cfg . start_address == address : cfg_rv = cfg break return cfg_rv
|
Return the cfg of the requested function by address .
|
9,679
|
def all_simple_bb_paths ( self , start_address , end_address ) : bb_start = self . _find_basic_block ( start_address ) bb_end = self . _find_basic_block ( end_address ) paths = networkx . all_simple_paths ( self . _graph , source = bb_start . address , target = bb_end . address ) return ( [ self . _bb_by_addr [ addr ] for addr in path ] for path in paths )
|
Return a list of path between start and end address .
|
9,680
|
def build ( self , start , end , symbols = None ) : symbols = { } if not symbols else symbols bbs = self . _recover_bbs ( start , end , symbols ) bbs = self . _split_bbs ( bbs , symbols ) call_targets = self . _extract_call_targets ( bbs ) return bbs , call_targets
|
Return the list of basic blocks .
|
9,681
|
def parse_operand ( string , location , tokens ) : sizes = { "dqword" : 128 , "pointer" : 72 , "qword" : 64 , "pointer" : 40 , "dword" : 32 , "word" : 16 , "byte" : 8 , "bit" : 1 , } if "immediate" in tokens : imm_str = "" . join ( tokens [ "immediate" ] ) base = 16 if imm_str . startswith ( "0x" ) or imm_str . startswith ( "-0x" ) else 10 imm = int ( imm_str , base ) oprnd = ReilImmediateOperand ( imm ) if "register" in tokens : if tokens [ "register" ] in [ "e" , "empty" ] : oprnd = ReilEmptyOperand ( ) oprnd . size = 0 else : name = tokens [ "register" ] oprnd = ReilRegisterOperand ( name ) if "size" in tokens : oprnd . size = int ( sizes [ tokens [ "size" ] ] ) return [ oprnd ]
|
Parse instruction operand .
|
9,682
|
def parse_instruction ( string , location , tokens ) : mnemonic_str = ReilMnemonic . from_string ( tokens [ "mnemonic" ] ) oprnd1 = tokens [ "fst_operand" ] [ 0 ] oprnd2 = tokens [ "snd_operand" ] [ 0 ] oprnd3 = tokens [ "trd_operand" ] [ 0 ] ins_builder = ReilBuilder ( ) return ins_builder . build ( mnemonic_str , oprnd1 , oprnd2 , oprnd3 )
|
Parse instruction .
|
9,683
|
def parse ( self , instrs ) : instrs_reil = [ ] try : for instr in instrs : instr_lower = instr . lower ( ) if instr_lower not in self . _cache : self . _cache [ instr_lower ] = instruction . parseString ( instr_lower ) [ 0 ] instrs_reil += [ copy . deepcopy ( self . _cache [ instr_lower ] ) ] except : error_msg = "Failed to parse instruction: %s" logger . error ( error_msg , instr , exc_info = True ) return instrs_reil
|
Parse an IR instruction .
|
9,684
|
def parse_operand ( string , location , tokens ) : if "immediate_operand" in tokens : size = arch_info . operand_size oprnd = ArmImmediateOperand ( "" . join ( tokens [ "immediate_operand" ] ) , size ) if "register_operand" in tokens : oprnd = process_register ( tokens [ "register_operand" ] ) if "wb" in tokens [ "register_operand" ] : oprnd . wb = True if "memory_operand" in tokens : mem_oprnd = tokens [ "memory_operand" ] if "offset" in mem_oprnd : index_type = ARM_MEMORY_INDEX_OFFSET mem_oprnd = mem_oprnd [ "offset" ] elif "pre" in mem_oprnd : index_type = ARM_MEMORY_INDEX_PRE mem_oprnd = mem_oprnd [ "pre" ] elif "post" in mem_oprnd : index_type = ARM_MEMORY_INDEX_POST mem_oprnd = mem_oprnd [ "post" ] else : raise Exception ( "Unknown index type." ) reg_base = process_register ( mem_oprnd [ "base" ] ) disp = mem_oprnd . get ( "disp" , None ) disp_minus = True if mem_oprnd . get ( "minus" ) else False if disp : if "shift" in disp : displ_imm = process_shifted_register ( disp [ "shift" ] ) elif "reg" in disp : displ_imm = process_register ( disp [ "reg" ] ) elif "imm" in disp : displ_imm = ArmImmediateOperand ( "" . join ( disp [ "imm" ] ) , arch_info . operand_size ) else : raise Exception ( "Unknown displacement type." ) else : displ_imm = None size = arch_info . operand_size oprnd = ArmMemoryOperand ( reg_base , index_type , displ_imm , disp_minus , size ) if "shifted_register" in tokens : oprnd = process_shifted_register ( tokens [ "shifted_register" ] ) if "register_list_operand" in tokens : parsed_reg_list = tokens [ "register_list_operand" ] reg_list = [ ] for reg_range in parsed_reg_list : start_reg = process_register ( reg_range [ 0 ] ) if len ( reg_range ) > 1 : end_reg = process_register ( reg_range [ 1 ] ) reg_list . append ( [ start_reg , end_reg ] ) else : reg_list . append ( [ start_reg ] ) oprnd = ArmRegisterListOperand ( reg_list , reg_list [ 0 ] [ 0 ] . size ) return oprnd
|
Parse an ARM instruction operand .
|
9,685
|
def parse_instruction ( string , location , tokens ) : mnemonic_str = tokens . get ( "mnemonic" ) operands = [ op for op in tokens . get ( "operands" , [ ] ) ] instr = ArmInstruction ( string , mnemonic_str [ "ins" ] , operands , arch_info . architecture_mode ) if "cc" in mnemonic_str : instr . condition_code = cc_mapper [ mnemonic_str [ "cc" ] ] if "uf" in mnemonic_str : instr . update_flags = True if "ldm_stm_addr_mode" in mnemonic_str : instr . ldm_stm_addr_mode = ldm_stm_am_mapper [ mnemonic_str [ "ldm_stm_addr_mode" ] ] return instr
|
Parse an ARM instruction .
|
9,686
|
def get_next_scheduled_time ( cron_string ) : itr = croniter . croniter ( cron_string , datetime . utcnow ( ) ) return itr . get_next ( datetime )
|
Calculate the next scheduled time by creating a crontab object with a cron string
|
9,687
|
def rationalize_until ( until = None ) : if until is None : until = "+inf" elif isinstance ( until , datetime ) : until = to_unix ( until ) elif isinstance ( until , timedelta ) : until = to_unix ( ( datetime . utcnow ( ) + until ) ) return until
|
Rationalizes the until argument used by other functions . This function accepts datetime and timedelta instances as well as integers representing epoch values .
|
9,688
|
def register_death ( self ) : self . log . info ( 'Registering death' ) with self . connection . pipeline ( ) as p : p . hset ( self . scheduler_key , 'death' , time . time ( ) ) p . expire ( self . scheduler_key , 60 ) p . execute ( )
|
Registers its own death .
|
9,689
|
def acquire_lock ( self ) : key = '%s_lock' % self . scheduler_key now = time . time ( ) expires = int ( self . _interval ) + 10 self . _lock_acquired = self . connection . set ( key , now , ex = expires , nx = True ) return self . _lock_acquired
|
Acquire lock before scheduling jobs to prevent another scheduler from scheduling jobs at the same time .
|
9,690
|
def remove_lock ( self ) : key = '%s_lock' % self . scheduler_key if self . _lock_acquired : self . connection . delete ( key )
|
Remove acquired lock .
|
9,691
|
def _install_signal_handlers ( self ) : def stop ( signum , frame ) : self . log . info ( 'Shutting down RQ scheduler...' ) self . register_death ( ) self . remove_lock ( ) raise SystemExit ( ) signal . signal ( signal . SIGINT , stop ) signal . signal ( signal . SIGTERM , stop )
|
Installs signal handlers for handling SIGINT and SIGTERM gracefully .
|
9,692
|
def _create_job ( self , func , args = None , kwargs = None , commit = True , result_ttl = None , ttl = None , id = None , description = None , queue_name = None , timeout = None , meta = None ) : if args is None : args = ( ) if kwargs is None : kwargs = { } job = self . job_class . create ( func , args = args , connection = self . connection , kwargs = kwargs , result_ttl = result_ttl , ttl = ttl , id = id , description = description , timeout = timeout , meta = meta ) if self . _queue is not None : job . origin = self . _queue . name else : job . origin = queue_name or self . queue_name if commit : job . save ( ) return job
|
Creates an RQ job and saves it to Redis .
|
9,693
|
def enqueue_at ( self , scheduled_time , func , * args , ** kwargs ) : timeout = kwargs . pop ( 'timeout' , None ) job_id = kwargs . pop ( 'job_id' , None ) job_ttl = kwargs . pop ( 'job_ttl' , None ) job_result_ttl = kwargs . pop ( 'job_result_ttl' , None ) job_description = kwargs . pop ( 'job_description' , None ) meta = kwargs . pop ( 'meta' , None ) job = self . _create_job ( func , args = args , kwargs = kwargs , timeout = timeout , id = job_id , result_ttl = job_result_ttl , ttl = job_ttl , description = job_description , meta = meta ) self . connection . zadd ( self . scheduled_jobs_key , { job . id : to_unix ( scheduled_time ) } ) return job
|
Pushes a job to the scheduler queue . The scheduled queue is a Redis sorted set ordered by timestamp - which in this case is job s scheduled execution time .
|
9,694
|
def schedule ( self , scheduled_time , func , args = None , kwargs = None , interval = None , repeat = None , result_ttl = None , ttl = None , timeout = None , id = None , description = None , queue_name = None , meta = None ) : if interval is not None and result_ttl is None : result_ttl = - 1 job = self . _create_job ( func , args = args , kwargs = kwargs , commit = False , result_ttl = result_ttl , ttl = ttl , id = id , description = description , queue_name = queue_name , timeout = timeout , meta = meta ) if interval is not None : job . meta [ 'interval' ] = int ( interval ) if repeat is not None : job . meta [ 'repeat' ] = int ( repeat ) if repeat and interval is None : raise ValueError ( "Can't repeat a job without interval argument" ) job . save ( ) self . connection . zadd ( self . scheduled_jobs_key , { job . id : to_unix ( scheduled_time ) } ) return job
|
Schedule a job to be periodically executed at a certain interval .
|
9,695
|
def cron ( self , cron_string , func , args = None , kwargs = None , repeat = None , queue_name = None , id = None , timeout = None , description = None , meta = None ) : scheduled_time = get_next_scheduled_time ( cron_string ) job = self . _create_job ( func , args = args , kwargs = kwargs , commit = False , result_ttl = - 1 , id = id , queue_name = queue_name , description = description , timeout = timeout , meta = meta ) job . meta [ 'cron_string' ] = cron_string if repeat is not None : job . meta [ 'repeat' ] = int ( repeat ) job . save ( ) self . connection . zadd ( self . scheduled_jobs_key , { job . id : to_unix ( scheduled_time ) } ) return job
|
Schedule a cronjob
|
9,696
|
def cancel ( self , job ) : if isinstance ( job , self . job_class ) : self . connection . zrem ( self . scheduled_jobs_key , job . id ) else : self . connection . zrem ( self . scheduled_jobs_key , job )
|
Pulls a job from the scheduler queue . This function accepts either a job_id or a job instance .
|
9,697
|
def change_execution_time ( self , job , date_time ) : with self . connection . pipeline ( ) as pipe : while 1 : try : pipe . watch ( self . scheduled_jobs_key ) if pipe . zscore ( self . scheduled_jobs_key , job . id ) is None : raise ValueError ( 'Job not in scheduled jobs queue' ) pipe . zadd ( self . scheduled_jobs_key , { job . id : to_unix ( date_time ) } ) break except WatchError : if pipe . zscore ( self . scheduled_jobs_key , job . id ) is None : raise ValueError ( 'Job not in scheduled jobs queue' ) continue
|
Change a job s execution time .
|
9,698
|
def count ( self , until = None ) : until = rationalize_until ( until ) return self . connection . zcount ( self . scheduled_jobs_key , 0 , until )
|
Returns the total number of jobs that are scheduled for all queues . This function accepts datetime timedelta instances as well as integers representing epoch values .
|
9,699
|
def get_jobs ( self , until = None , with_times = False , offset = None , length = None ) : def epoch_to_datetime ( epoch ) : return from_unix ( float ( epoch ) ) until = rationalize_until ( until ) job_ids = self . connection . zrangebyscore ( self . scheduled_jobs_key , 0 , until , withscores = with_times , score_cast_func = epoch_to_datetime , start = offset , num = length ) if not with_times : job_ids = zip ( job_ids , repeat ( None ) ) for job_id , sched_time in job_ids : job_id = job_id . decode ( 'utf-8' ) try : job = self . job_class . fetch ( job_id , connection = self . connection ) except NoSuchJobError : self . cancel ( job_id ) continue if with_times : yield ( job , sched_time ) else : yield job
|
Returns a iterator of job instances that will be queued until the given time . If no until argument is given all jobs are returned .
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.