HexraysToolbox

Boîte à outils Hexray

Hexrays Toolbox (HXTB) est un puissant ensemble de scripts iDapython qui peuvent être utilisés pour trouver et localiser des modèles de code dans des binaires, indépendants de leur architecture de processeur sous-jacente.

Cas d'utilisation

• Analyser les fichiers binaires pour les vulnérabilités et les variantes
• Localisez les modèles de code à partir d'exécutables précédemment inversés dans le code nouvellement décompilé
• Analyse des variantes de logiciels malveillants
• Trouvez des similitudes de code sur plusieurs binaires (c'est-à-dire pour prouver le "vol de code", violations de licence, ...)
• Trouver des modèles de code à partir de binaires compilés pour l'architecture a en binaires compilés pour l'architecture b
• Probablement beaucoup plus ...

La requête illustrée par l'animation ci-dessous est un exemple de la façon dont une vulnérabilité qui a affecté WhatsApp pour Android (CVE-2019-3568, libwhatsapp.so) peut être située à l'aide de la boîte à outils Hexrays. Cela se fait en formulant un modèle de code souhaité qui doit être localisé à l'aide d'une fonction IDAPHTHON LAMBDA. Trouvez l'exemple de script .

Exigences

Une licence IDA valide et une licence de décompilateur HEXRAYS valide par architecture cible sont nécessaires.

Usage

Il existe plusieurs façons d'utiliser la boîte à outils Hexrays, chacune avec un degré de flexibilité variable.

• Exécutez des requêtes au nom de HXTB_SHELL, une GUI interactive
• Scripting idapython personnalisé
• interactive.py , un script qui ajoute des fonctions de commodité à utiliser avec l'interface de ligne de commande IDA
• automation.py , un script qui traite et exécute les requêtes HXTB sur un ensemble donné de fichiers en mode lot

shell hxtb

L'exécution du script hxtb_shell.py inclus à partir de l'IDA ouvre une fenêtre GUI qui peut être utilisée pour développer, charger et exécuter les requêtes HXTB. La capture d'écran ci-dessous montre à quoi peut ressembler une requête chargée de shell HXTB.

HXTB Shell accepte également les expressions Python qui sont créées par la visionneuse de contexte du plugin Hrdevhelper. Ils peuvent être copiés à partir de celui-ci et directement collés dans l'interface graphique HXTB-Shell.

---

D'autres exemples de requêtes qui peuvent être chargés de shell HXTB peuvent être trouvées dans le sous-fichier hxtbshell_queries incluses avec Hexrays Toolbox.

Script

Le chargement hxtb.py avec Ida (alt-f7) rend des fonctions telles que find_expr() et find_item() disponibles à la fois pour l'Idapython CLI et l'interpréteur de script (Shift-F2). Entre autres, ces fonctions peuvent être utilisées pour exécuter des requêtes sur la base de données IDA actuellement chargée. Veuillez consulter certains des exemples ci-dessous.

    find_item(ea, q)
    find_expr(ea, q)

    Positional arguments:
        ea:         address of a valid function within
                    the current database
        q:          lambda function
                    custom lambda function with the following arguments:
                    1. cfunc: cfunc_t
                    2. i/e:   cinsn_t/cexpr_t
    Returns:
        list of query_result_t objects

    Example:
        find_expr(here(), lambda cf, e: e.op is cot_call)
    
        -> finds and returns all function calls within a current function.
        The returned data is a list of query_result_t objects (see hxtb.py).

        The returned list can be passed to an instance of the ic_t class,
        which causes the data to be displayed by a chooser as follows:

        from idaapi import *
        import hxtb
        hxtb.ic_t(find_expr(here(), lambda cf,e:e.op is cot_call))


    Please find the cfunc_t, citem_t, cinsn_t and cexpr_t structures
    within hexrays.hpp for further help and details.

Exemples

Liste des expressions qui comparent n'importe quoi à zéro ("x == 0")

         cot_eq
         /   
      x /      y
(anything)  cot_num --- n.numval() == 0

 from idaapi import *
from hxtb import find_expr
query = lambda cfunc , e : e . op is cot_eq and e . y . op is cot_num and e . y . numval () == 0
r = find_expr ( here (), query )
for e in r :
    print ( e )

Liste des appels de fonction (directs)

        cot_call
         / 
      x /
 cot_obj

 from idaapi import *
from hxtb import find_expr
query = lambda cfunc , e : e . op is cot_call and e . x . op is cot_obj
r = find_expr ( here (), query )
for e in r :
    print ( e )

Liste des appels memcpy où l'argument "DST" est sur la pile

        cot_call --- arg1 is cot_var
         /           arg1 is on stack
      x /
 cot_obj --- name(obj_ea) == 'memcpy'

 from idaapi import *
from hxtb import find_expr
r = []
query = lambda cfunc , e : ( e . op is cot_call and
           e . x . op is cot_obj and
           get_name ( e . x . obj_ea ) == 'memcpy' and
           len ( e . a ) == 3 and
           e . a [ 0 ]. op is cot_var and
           cfunc . lvars [ e . a [ 0 ]. v . idx ]. is_stk_var ())
for ea in Functions ():
    r += find_expr ( ea , query )
for e in r :
    print ( e )

Liste des appels à sprintf (str, fmt, ...) où FMT contient "% s"

        cot_call --- arg2 ('fmt') contains '%s'
         /
      x /
 cot_obj --- name(obj_ea) == 'sprintf'

 from idaapi import *
from hxtb import find_expr
r = []
query = lambda cfunc , e : ( e . op is cot_call and
    e . x . op is cot_obj and
    get_name ( e . x . obj_ea ) == 'sprintf' and
    len ( e . a ) >= 2 and
    e . a [ 1 ]. op is cot_obj and
    is_strlit ( get_flags ( get_item_head ( e . a [ 1 ]. obj_ea ))) and
    b'%s' in get_strlit_contents ( e . a [ 1 ]. obj_ea , - 1 , 0 , STRCONV_ESCAPE ))
for ea in Functions ():
    r += find_expr ( ea , query )
for e in r :
    print ( e )

Afficher toutes les instructions à l'aide d'opérateurs signés dans une vue de liste

 from idaapi import *
from hxtb import ic_t
query = lambda cfunc , e : ( e . op in
            [ cot_asgsshr , cot_asgsdiv ,
            cot_asgsmod , cot_sge ,
            cot_sle , cot_sgt ,
            cot_slt , cot_sshr ,
            cot_sdiv , cot_smod ])
ic_t ( query )

Afficher toutes les instructions "if" dans une vue de liste

 from idaapi import *
from hxtb import ic_t
ic_t ( lambda cf , i : i . op is cit_if )

Trouvez toutes les instructions de boucle dans la base de données actuelle, affichez une vue de liste

 from idaapi import *
from hxtb import ic_t , query_db
ic_t ( query_db ( lambda cf , i : is_loop ( i . op )))

Afficher les opérations potentielles de copie de mémoire dans une vue de liste

 from hxtb import ic_t , query_db , find_child_expr
from ida_hexrays import *


find_copy_query = lambda cfunc , i : ( i . op is cot_asg and
                                i . x . op is cot_ptr and
                                i . y . op is cot_ptr )

find_loop_query = lambda cfunc , i : ( is_loop ( i . op ) and
                            find_child_expr ( cfunc , i , find_copy_query ))


ic_t ( query_db ( find_loop_query ))