FindFunc : Filtrage/Recherche avancé de fonctions dans IDA Pro

FindFunc est un plugin IDA Pro pour trouver des fonctions de code qui contiennent un certain motif assembleur ou d'octets, référencent un certain nom ou une chaîne, ou sont conformes à diverses autres contraintes.

FindFunc a remporté la troisième place au Concours de plugins IDA Pro HexRays 2022 !

Filtrage avec des règles

La fonctionnalité principale de FindFunc est de permettre à l'utilisateur de spécifier un ensemble de « Règles » ou contraintes qu'une fonction de code dans IDA Pro doit satisfaire. FF trouvera et listera alors toutes les fonctions qui satisfont TOUTES les règles (donc actuellement toutes les règles sont en conjonction ET). Exception : les règles peuvent être « inversées » pour être des correspondances négatives. De telles règles respectent donc « ET NON ».

FF planifiera les règles dans un ordre intelligent pour minimiser le temps de traitement. Aperçu des fonctionnalités :

• 6 règles disponibles actuellement, voir ci-dessous
• Conscient des chunks de fonctions
• Planification intelligente des règles pour la performance
• Sauvegarde/Chargement des règles depuis/vers un fichier au format ASCII simple
• Plusieurs onglets indépendants pour l'expérimentation
• Copie des règles entre les onglets via le presse-papiers (même format que le format de fichier)
• Sauvegarde de la session entière (tous les onglets) dans un fichier
• Copie avancée des octets d'instructions (tout, opcodes seulement, tout sauf les immédiats, ...)
• Cloner des onglets pour des expériences rapides avec le raffinement des résultats
• La correspondance de code respecte le préfixe de taille d'adresse et le préfixe de taille d'opérande

Le bouton « Find Functions » efface les résultats existants et lance une nouvelle recherche, « Refine Results » ne considère que les résultats de la recherche précédente.

Copie binaire avancée

Une fonctionnalité secondaire de FF est l'option de copier la représentation binaire des instructions avec les options suivantes :

• tout copier -> copie tous les octets dans le presse-papiers
• copier sans immédiats -> masque (AA ?? BB) toutes les valeurs immédiates dans les octets de l'instruction
• opcode seulement -> masquera tout sauf le(s) opcode(s) réel(s) de l'instruction (et les préfixes)
• ...

Voir la section « copie avancée » ci-dessous pour les détails. Cette fonctionnalité complète bien la règle de motif d'octets !

Construction et Installation

FindFunc est un plugin Python IDA Pro sans dépendances de paquets externes. Il peut être installé en téléchargeant le dépôt et en copiant le fichier 'findfuncmain.py' et le dossier 'findfunc' dans votre répertoire de plugins IDA Pro. Pour IDA 9.0+, le dépôt peut également être cloné directement dans le répertoire des plugins. Dans les deux cas, aucune compilation n'est requise.

Prérequis : IDA Pro 8.x (8.3+) avec environnement python3. FindFunc est conçu uniquement pour l'architecture x86/x64. Il a été testé avec IDA 8.3 - 9.2, Python 3.11 sur Windows 10 + 11

Règles disponibles

Actuellement, les six règles suivantes sont disponibles. Elles sont triées ici de lourde à légère en ce qui concerne l'impact sur les performances. Avec de grandes bases de données, il est conseillé de réduire d'abord les fonctions candidates avec une règle peu coûteuse, avant d'effectuer une correspondance lourde via, par exemple, les règles de code. FF planifiera automatiquement les règles de manière intelligente.

Motif de code

Règle pour filtrer les fonctions en fonction de la présence d'un extrait de code assembleur donné. Ce n'est PAS une recherche textuelle de la représentation de désassemblage textuelle d'IDA, mais plutôt une correspondance avancée de l'instruction sous-jacente. L'extrait peut contenir plusieurs instructions consécutives, une par ligne. Les chunks de fonctions sont pris en charge. Prend en charge la correspondance avec des caractères génériques spéciaux, en plus de l'assembleur littéral :

• « pass » -> correspond à toute instruction avec n'importe quels opérandes
• « mov* any,any » -> correspond aux instructions avec le mnémonique « mov* » (par exemple mov, movzx, ...) et deux arguments quelconques.
• « mov eax, r32 » -> correspond à toute instruction avec le mnémonique « mov », premier opérande registre eax et second opérande tout registre 32 bits.
  • Analogue : r pour tout registre, r8/r16/r32/r64 pour un registre de largeur spécifique, « imm » pour tout immédiat
• « mov r64, imm » -> correspond à tout déplacement d'une constante vers un registre 64 bits
• « any r64,r64 » -> correspond à toute opération entre deux registres 64 bits
• mov -> correspond à toute instruction du mnémonique mov

plus d'exemples :

mov r64, [r32 * 8 + 0x100]
mov r, [r * 8 - 0x100]
mov r64, [r32 * 8 + imm]
pass
mov r, word [eax + r32 * 8 - 0x100]
any r64, r64
push imm
push any

Pièges : Soyez prudent lorsque vous copiez de l'assembleur depuis IDA. IDA mélange les noms de variables locales et d'autres informations dans l'instruction, ce qui entraîne un échec de la correspondance. De plus, les labels ne sont pas pris en charge (« call sub_123456 »).

Notez que les motifs de code sont la règle la plus coûteuse, et si seules les règles de code sont présentes, FF n'a d'autre choix que de désassembler l'intégralité de la base de données. Cela peut prendre jusqu'à plusieurs minutes pour de très gros binaires. Voir les notes sur les performances ci-dessous.

Valeur immédiate (Constante)

La fonction doit contenir la valeur immédiate donnée au moins une fois dans n'importe quelle position. Une valeur immédiate est une valeur fixée dans la représentation binaire de l'instruction. Exemples d'instructions correspondant à la valeur immédiate 0x100 :

mov eax, 0x100
mov eax, [0x100]
and al, [eax + ebx*8 + 0x100]
push 0x100

Les immédiats peuvent être collés directement depuis le presse-papiers dans la liste des règles. Remarque : IDA effectue une correspondance étendue de toute taille et de toute position de l'immédiat. Si vous savez qu'il s'agit d'une largeur spécifique de 4 ou 8 octets, un motif d'octets peut être plus rapide (mais peut produire des faux positifs).

Motif d'octets

La fonction doit contenir le motif d'octets donné au moins une fois. Le motif est du même format que la recherche binaire d'IDA et prend donc en charge les caractères génériques - la correspondance parfaite pour la fonction de copie avancée !

Exemples :

11 22 33 44 aa bb cc
11 22 33 ?? ?? bb cc -> ?? peut être n'importe quel octet

Les motifs d'octets peuvent être collés directement depuis le presse-papiers dans la liste des règles. Remarque : La correspondance de motifs est assez rapide et un bon candidat pour réduire rapidement les correspondances !

Référence de chaîne

La fonction doit référencer la chaîne donnée au moins une fois. La chaîne est mise en correspondance selon le module 'fnmatch' de Python, et prend donc en charge une correspondance de type caractère générique. La correspondance est effectuée sans tenir compte de la casse. Les chaînes des formats suivants sont considérées : [idaapi.STRTYPE_C, idaapi.STRTYPE_C_16] (cela peut être modifié dans la classe Config).

Exemples :

• « TestString » -> la fonction doit référencer la chaîne exacte (casse ignorée) au moins une fois
• « TestStr* » -> la fonction doit référencer une chaîne commençant par 'TestStr' (par exemple TestString, TestStrong) au moins une fois (casse ignorée)

Remarque : La correspondance de chaînes est rapide et un bon choix pour réduire rapidement les candidats !

Référence de nom

La fonction doit référencer le nom/label donné au moins une fois. Le nom/label est mis en correspondance selon le module 'fnmatch' de Python, et prend donc en charge une correspondance de type caractère générique. La correspondance est effectuée sans tenir compte de la casse.

Exemples :

• « memset » -> la fonction doit référencer un nom « memset » au moins une fois
• « mem* » -> la fonction doit référencer un nom commençant par « mem » (memset, memcpy, memcmp) au moins une fois

Remarque : La correspondance de noms est très rapide et idéale pour réduire rapidement les candidats !

Taille de fonction

La taille de la fonction doit être dans la limite donnée : « min <= functionsize <= max ». Les données sont saisies sous forme de chaîne de la forme « min,max ». La taille d'une fonction inclut tous ses chunks.

Remarque : La correspondance de taille de fonction est très rapide et idéale pour réduire rapidement les candidats !

Raccourcis clavier et interface graphique

Pour faciliter l'utilisation, FF peut être utilisé via les raccourcis clavier suivants :

• Ctrl+Alt+F -> lancer/afficher le TabWidget (interface graphique principale)
  • Ou Affichage->FindFunc
• Ctrl+F -> démarrer la recherche avec les règles actuellement activées
• Ctrl+R -> affiner les résultats existants avec les règles actuellement activées
• Règles
  • Ctrl+C -> copier les règles sélectionnées dans le presse-papiers
  • Ctrl+V -> coller les règles depuis le presse-papiers dans l'onglet actuel (ajoute)
  • Ctrl+S -> enregistrer les règles sélectionnées dans un fichier
  • Ctrl+L -> charger les règles sélectionnées depuis un fichier (ajoute)
  • Ctrl+A -> sélectionner toutes les règles
  • Suppr -> supprimer les règles sélectionnées
• Enregistrer la session
  • Ctrl+Shift+S -> Enregistrer la session dans un fichier
  • Ctrl+Shift+L -> Charger la session depuis un fichier

Utilisation supplémentaire de l'interface

• Clic droit sur l'onglet : option pour cloner l'onglet
• Les règles peuvent être modifiées en double-cliquant sur la colonne Données
• Les règles peuvent être inversées (correspondance négative) en double-cliquant sur la colonne d'inversion de correspondance
• Les règles peuvent être activées/désactivées en double-cliquant sur la colonne d'activation
• Clic molette sur n'importe quelle cellule dans Règles ou Résultats copie la cellule dans le presse-papiers
• Les motifs d'octets et les immédiats peuvent être collés directement depuis le presse-papiers dans la table des règles
• Les onglets peuvent être renommés en double-cliquant dessus
• Le tri est pris en charge pour la liste des règles et la liste des résultats
• Double-cliquer sur un élément de résultat pour y accéder dans IDA
  • nom de la fonction : sauter au début de la fonction
  • toute autre colonne : sauter à la correspondance de la dernière règle correspondante
• Case à cocher Profil : affiche les informations de profilage pour la recherche
• Case à cocher Débogage : vide la sortie de débogage détaillée pour la correspondance des règles de code - à utiliser uniquement si peu de fonctions passent à la règle de vérification de code, sinon cela peut prendre très longtemps !

Copie binaire avancée

Fréquemment, nous voulons rechercher des motifs binaires d'assembleur, mais sans adresses et valeurs codées en dur (immédiats), ou même seulement les opcodes réels de l'instruction. FindFunc facilite cela en ajoutant trois options de copie au menu contextuel du désassemblage :

Copier tous les octets

Copie tous les octets d'instructions sous forme de chaîne hexadécimale dans le presse-papiers, pour utilisation dans une règle de motif d'octets (ou la recherche binaire d'IDA).

B8 44332211      mov eax,11223344
68 00000001      push 1000000
66:894424 70     mov word ptr ss:[esp+70],ax

sera copié comme

b8 44 33 22 11 68 00 00 00 01 66 89 44 24 70

Copier uniquement les octets non immédiats

Copie les octets d'instructions pour l'instruction donnée, en masquant toutes les valeurs immédiates. Exemple :

B8 44332211      mov eax,11223344
68 00000001      push 1000000
66:894424 70     mov word ptr ss:[esp+70],ax

sera copié comme

b8 ?? ?? ?? ?? 68 ?? ?? ?? ?? 66 89 44 24 ??

Copier uniquement les opcodes

Copie tous les octets d'instructions sous forme de chaîne hexadécimale dans le presse-papiers, en masquant tous les octets qui ne sont pas l'opcode réel (y compris sib, modrm, mais en conservant les préfixes hérités).

B8 44332211      mov eax,11223344
68 00000001      push 1000000
66:894424 70     mov word ptr ss:[esp+70],ax

sera copié comme

b8 ?? ?? ?? ?? 68 ?? ?? ?? ?? 66 89 ?? ?? ??

Copier opcodes + immédiats

Une combinaison qui conserve l'opcode et les immédiats, mais masque par exemple mod r/m. Notez que cela conserve les opcodes même s'ils imposent des registres spécifiques, par exemple

B8 44332211      mov eax,11223344

conservera l'opcode B8.

Remarque : Il s'agit d'un « meilleur effort » utilisant l'API d'IDA, donc il peut y avoir quelques cas où cela ne fonctionne que partiellement. Pour une solution 100 % correcte, nous devrions inclure une bibliothèque de désassemblage x86 dédiée.

Des résultats similaires peuvent être obtenus avec les règles de motif de code, mais cela peut être plus rapide, tant pour l'interaction utilisateur que pour la recherche réelle.

Copier le désassemblage

Copie le désassemblage sélectionné dans le presse-papiers, tel qu'il apparaît dans IDA.

Performances

Un mot rapide sur les performances :

1. le nom, la chaîne, la taille de fonction sont quasiment gratuits dans tous les cas
2. le motif d'octets est quasiment gratuit pour des motifs de longueur > 2
3. l'immédiat est difficile : Nous pouvons utiliser la recherche idaapi, ou désassembler l'intégralité de la base de données et chercher nous-mêmes - nous devrons peut-être le faire de toute façon si nous recherchons des motifs de code. MAIS : la recherche de motifs de code est en fait beaucoup moins coûteuse que la recherche d'un immédiat. Une recherche via l'API pour toutes les correspondances est relativement coûteuse - environ 1/8 du coût du désassemblage de toute la base de données. Donc : si nous réduisons d'abord les correspondances avec des règles peu coûteuses, nous profitons grandement du désassemblage des fonctions restantes et de la recherche de l'immédiat par nous-mêmes, surtout si une règle de code est de toute façon présente. Cependant : s'il n'existe pas d'options peu coûteuses et que nous devons de toute façon désassembler de grandes parties de la base de données (en raison de la présence de règles de motif de code), l'utilisation d'une règle d'immédiat comme pré-filtre peut être très avantageuse. La recherche via l'API d'UN seul immédiat équivaut à environ 1/8 de la recherche d'un nombre quelconque de règles de motif de code - bien que cela dépende aussi de nombreux facteurs différents...
4. les motifs de code sont de loin les plus coûteux, mais vérifier un motif par rapport à vérifier plusieurs motifs est très similaire.

À faire (non ordonné) :

• pseudo-mnémonique jcc
• Permettre les emplacements nommés dans les règles de code ('call memset')
• ajouter une règle de xref entrante/sortante
• annuler/rétablir
• barre de progression
• clic central pour fermer les onglets
• menu des onglets : fermer tous sauf celui-ci
• option « ignorer tous les opérandes suivants »
• Règle pour les paramètres des appels API à l'intérieur de la fonction
• Règle pour les exigences de fonction parente/site d'appel/enfant
• Règle pour les paramètres de fonction
• Règle d'expression régulière
• chaîne/nom : option de casse
• convertir automatiquement les règles d'immédiat en motif d'octets si applicable ?
• paramètres : sensibilité à la casse, types de chaînes, plage, ...
• Règles Hex-Rays ?
• Combinaison OU de règles
• Pythonification du code ;)
• Parallélisation
• Génération automatique de règles pour identifier une fonction ?