Ghidra Downloadguide indépendant de téléchargement et d’installation
Français
GUIDE DE MODÉLISATION DES DONNÉES

Types de données Ghidra : définir structures, tableaux et pointeurs

Les types de données Ghidra transforment une plage d’octets inexpliquée en interprétation vérifiable. Ce guide montre comment ouvrir Data Type Manager, appliquer des types primitifs, créer une structure, utiliser tableaux et pointeurs, puis contrôler chaque modification dans Listing et Decompiler sans confondre une hypothèse utile avec une preuve.

Read the official Ghidra Data documentation
Idéal pourExpliquer les octets et les champs
Commencer dansListing de CodeBrowser
Résultat principalDonnées définies et champs nommés
Vérifier avecListing et Décompilateur
RÉPONSE RAPIDE

Ce que signifient les types de données Ghidra

Les types de données Ghidra décrivent la manière dont une plage d’octets doit être lue. Un programme nouvellement importé contient des octets indéfinis, souvent affichés par des points d’interrogation, jusqu’à ce que l’analyse ou l’analyste applique un type. Appliquer un type ne réécrit pas le fichier original : cela ajoute une interprétation au modèle du programme. Un octet peut ainsi représenter un entier signé, un pointeur, une chaîne, un champ de structure, un élément de tableau ou un autre type pris en charge.

La limite essentielle sépare la preuve de l’interprétation. Les octets, l’adresse, le langage processeur, l’endianness, les références et les accès répétés sont des preuves. Un nom comme `header`, `count` ou `next` est une interprétation qui doit être soutenue par ces faits. Un bon flux de types de données Ghidra note pourquoi un type a été choisi, vérifie sa taille et son alignement, et conserve une copie du projet lorsque l’hypothèse évolue. Plusieurs types peuvent expliquer les mêmes octets ; la trace des preuves reste donc déterminante.

Cette page se concentre sur la modélisation des données dans CodeBrowser. Le guide du décompilateur Ghidra explique comment de meilleurs types rendent le pseudo-code plus lisible, tandis que le guide de recherche Ghidra aide à trouver d’abord l’adresse ou la chaîne à modéliser.

Un type reste une hypothèse tant qu’il n’a pas résisté à une vérification — types de données Ghidra

Utilisez le type qui explique les octets et le schéma d’accès observés avec le moins d’hypothèses non vérifiées. Si des références ultérieures contredisent ce choix, annulez ou remplacez le type au lieu de forcer un résultat propre dans le décompilateur.

ConceptCe que cela indiqueÀ vérifier
Données indéfiniesBytes have no committed data interpretationAddress, block, encoding, and nearby references
Type primitifA known size and value representationLanguage, signedness, endianness, and alignment
StructureNamed fields at explicit offsetsField order, padding, size, and repeated accesses
PointeurA value interpreted as an addressAddress space, target type, and valid references
TableauRepeated elements with a fixed strideElement type, count, and total byte range
ÉTAPE 1

Ouvrir Data Type Manager et choisir une catégorie — types de données Ghidra

Ouvrez le programme dans CodeBrowser et affichez la fenêtre Data Type Manager depuis le menu Window. Sa position exacte dépend de votre espace de travail, mais le gestionnaire sépare généralement les types intégrés, les types fournis par le programme courant et ceux chargés depuis des archives. Commencez par la catégorie du programme et la famille réellement nécessaire ; importer une grande archive peut masquer le petit ensemble de types pertinent pour l’échantillon.

Les types intégrés conviennent aux valeurs primitives et aux chaînes courantes. Les types du programme sont l’endroit le plus sûr pour une structure encore en cours de test, car ils restent avec le projet. Les archives peuvent fournir des définitions de plateforme ou de bibliothèque, mais un nom identique ne prouve pas que la cible utilise le même ABI, le même packing ou la même version. Notez la source et le niveau de confiance de chaque type importé et comparez les candidats avant d’en retenir un.

Avant de modifier une adresse sélectionnée, notez l’adresse, l’affichage actuel et le nombre d’octets que vous prévoyez de consommer. Cette base simple rend visible un écrasement accidentel et permet de comparer le Listing avant et après l’opération.

  1. 1

    Sélectionner un programme et une adresse — types de données Ghidra

    Open a practice binary or authorized sample, choose an address in Listing, and confirm the active program and memory block.

    Program -> CodeBrowser -> Listing
  2. 2

    Afficher le gestionnaire — types de données Ghidra

    Choose Window > Data Type Manager and expand the categories without importing an unnecessary archive.

    Window -> Data Type Manager
  3. 3

    Choisir la source la plus précise — types de données Ghidra

    Use a built-in type for a primitive, a program type for an evolving structure, and an archive only when its ABI is supported.

    BuiltIn / Program / Archive
  4. 4

    Noter la référence initiale — types de données Ghidra

    Note the address, current bytes, block name, language, and expected size before applying a type.

    address + bytes + expected size
Boîte d’importation Ghidra montrant le contexte du programme avant la modélisation des données
Le contexte d’importation détermine le langage processeur et le modèle mémoire. Confirmez ces choix avant d’interpréter la taille des types primitifs.
ÉTAPE 2

Appliquer les types de données Ghidra primitifs sans perdre le contexte des octets

Les types primitifs sont le meilleur point de départ lorsque la preuve indique une largeur ou un encodage connus. Un byte, word, dword, qword, caractère, booléen, float ou pointeur peut modifier l’affichage du Listing sans modifier le fichier sur disque. Sélectionnez la plage correcte, choisissez la commande de données ou faites glisser un type depuis Data Type Manager, puis contrôlez immédiatement la taille obtenue. Gardez dans vos notes les types alternatifs lorsque la preuve demeure ambiguë.

Ne supposez pas qu’un entier possède la même largeur pour tous les langages processeur. Le langage et la spécification du compilateur déterminent la taille et la représentation de nombreux types intégrés. Le signe change aussi l’interprétation du bit de poids fort, tandis que l’endianness change l’ordre des octets qui forment une valeur. Si la valeur sert d’adresse, ne testez une interprétation en pointeur qu’après avoir confirmé l’espace d’adressage et les références voisines.

Lorsqu’une définition consomme des octets qui devraient rester séparés, annulez l’action et réduisez la sélection. Une commande réussie n’est pas forcément un modèle correct. Enregistrez les octets d’origine et l’adresse de fin attendue afin de repérer une plage décalée d’un octet ou un intervalle d’alignement.

  • Check processor language and address size before choosing a multi-byte type.
  • Use the observed access width and instruction operands as evidence for signedness and size.
  • Treat a pointer as an address hypothesis and verify its target in the active memory space.
  • Apply one definition at a time when learning a new binary so an incorrect range is easy to undo.
  • Keep a note of undefined bytes that remain between two known fields; gaps can be padding or a missing field.
A small evidence noteaddress: 0x00402010 | size: 4 | observed: little-endian load | type: uint32_t | confidence: medium
A conservative rulebytes -> type -> Listing check -> reference check -> Decompiler check
ÉTAPE 3

Créer et appliquer une structure Ghidra — types de données Ghidra

Créez une structure lorsque plusieurs champs sont utilisés à des offsets stables depuis la même base. Une structure est plus qu’une liste de suppositions : elle définit l’ordre, les offsets, les tailles et généralement une longueur totale. Commencez par le plus petit ensemble de champs confirmé par des lectures et écritures répétées. Vous pourrez ajouter des noms et des types lorsque les preuves s’améliorent, mais changer la taille d’un champ peut déplacer tous les champs suivants et modifier l’interprétation des appelants.

Dans Data Type Manager, créez une nouvelle structure dans la catégorie du programme, donnez-lui un nom temporaire et descriptif, puis ajoutez les champs dans l’ordre des offsets. N’utilisez un padding explicite que si l’alignement ou les accès observés justifient l’intervalle. Si un champ est un pointeur, appliquez le type de pointeur vers la cible la mieux défendable, plutôt qu’une structure choisie parce que son nom semble familier. Un nœud autoréférencé peut pointer vers la structure en cours de définition, mais vérifiez que le binaire suit réellement ce pointeur.

Une fois la structure définie, appliquez-la à l’adresse de base dans Listing. Vérifiez chaque limite de champ et comparez la taille totale avec l’objet connu suivant ou avec une autre instance. Deux instances séparées par un stride constant constituent une preuve utile d’un tableau de structures. Si l’objet suivant commence à un offset inattendu, gardez l’intervalle visible jusqu’à savoir s’il s’agit d’un padding, d’une union, d’une autre version ou d’un type de champ erroné.

  1. 1

    Créer une structure de programme — types de données Ghidra

    In Data Type Manager, choose the program category, create a structure, and use a temporary name that describes the evidence rather than an invented business meaning.

    Program Types -> New -> Structure
  2. 2

    Ajouter les champs dans l’ordre des offsets — types de données Ghidra

    Add the known primitive, array, enum, or pointer fields. Keep unknown bytes as undefined or explicit padding until a reference supports them.

    offset 0x00 -> field_0; offset 0x04 -> field_4
  3. 3

    Appliquer à la base — types de données Ghidra

    Select the base address in Listing, apply the structure, and verify that each displayed field ends where the next access expects.

    Listing -> Data -> apply structure
  4. 4

    Comparer les instances répétées — types de données Ghidra

    Search for the same access pattern or stride at another address before renaming the structure as a confirmed object.

    base + stride -> second instance
Décision de structurePreuve utileRisque en cas de supposition
Field sizeLoad/store width and repeated offsetEvery following field shifts
PaddingAlignment boundary or consistent gapA real field is hidden or the structure is too large
Pointer targetDereference and valid target referencesDecompiler shows a misleading object graph
Structure lengthNext object, array stride, or allocator sizeArrays and callers become inconsistent
ÉTAPE 4

Utiliser tableaux, énumérations, typedefs et pointeurs — types de données Ghidra

Un tableau convient lorsque le même type d’élément se répète avec un stride prévisible. Définissez d’abord l’élément, puis fixez un nombre seulement si une borne de boucle, une longueur de table, un objet voisin ou une taille d’allocation le confirme. Un compte inventé peut faire passer des octets sans rapport pour des éléments valides. Pour une chaîne terminée par zéro ou un tampon de taille variable, gardez la limite explicite au lieu d’imposer un tableau fixe que les preuves ne permettent pas.

Les énumérations améliorent la lisibilité lorsqu’une valeur est comparée à un petit ensemble répété de constantes. Ne nommez que les valeurs soutenues par les comparaisons ou la documentation et laissez visible toute valeur inconnue. Les typedefs donnent un nom de projet stable à un type primitif ou à un pointeur répété, mais ils ne créent aucune preuve. Ils sont surtout utiles lorsque le type sous-jacent et la convention d’appel sont déjà clairs.

Les pointeurs exigent le plus de discipline, car une valeur de pointeur n’a de sens que dans un espace d’adressage. Confirmez s’il pointe vers une structure, une chaîne, une fonction ou une table et vérifiez au moins une référence réelle. Une chaîne de pointeurs élégante dans Decompiler peut être fausse si l’adresse de base, le segment ou la largeur du type est incorrect. Notez toujours la cible et l’hypothèse d’espace d’adressage.

Ne laissez pas un type propre masquer une limite inconnue — types de données Ghidra

Il vaut mieux afficher un octet indéfini ou une valeur d’énumération inconnue que de rendre tout l’objet artificiellement certain. Une incertitude visible peut être testée ; un champ inventé ne le peut pas.

Motif de typeÀ utiliser lorsqueLimite à noter
TableauElements repeat with a known strideElement type and count or termination rule
EnumA value is compared with named constantsKnown values plus an explicit unknown case
TypedefA proven type needs a reusable project nameUnderlying type and calling convention
PointeurThe value is dereferenced or used as an addressAddress space and target type
Function pointerA table or call site uses an indirect callPrototype, table stride, and call evidence
VÉRIFICATION

Vérifier les types de données Ghidra dans Listing et Decompiler

Après avoir appliqué un type, revenez au Listing et inspectez les octets exacts, l’adresse, les offsets de champs et les références. Confirmez que la définition reste dans le bloc mémoire prévu et que les valeurs affichées correspondent aux instructions de lecture et d’écriture. Si elle recouvre une instruction ou une chaîne connue, arrêtez-vous et annulez-la. Listing est le registre au niveau adresse ; il doit rester compréhensible même si Decompiler n’est pas encore actualisé.

Sélectionnez ensuite une fonction qui lit l’objet typé et ouvrez Decompiler. Une signature, une structure ou un pointeur plus précis peut remplacer des valeurs indéfinies et des casts par des noms de champs, mais cette amélioration est un contrôle de cohérence, pas une preuve. Comparez une ou deux instructions décisives au pseudo-code, notamment le signe, l’arithmétique de pointeurs, l’indexation de tableau et les valeurs de retour. Si le résultat change après la fin de l’analyse, notez ce changement et revérifiez la preuve initiale.

Examinez les types comme un modèle connecté plutôt que comme des étiquettes isolées. Les types du Listing doivent correspondre à la signature de fonction, aux déréférencements et aux strides de tableaux. En cas de désaccord, conservez les types les plus simples soutenus par les preuves, marquez les types incertains comme provisoires et testez-les sur une autre référence avant de nommer l’objet avec assurance.

Consultez le guide Function Graph lorsqu’un champ est lu sur plusieurs branches, et le guide d’analyse firmware lorsque la carte d’adresses est incertaine. Ces pages répondent à des questions voisines ; cette page reste dédiée au modèle de données et à ses limites.

Vue du décompilateur Ghidra utilisée pour vérifier les champs de structure et les types de pointeurs
Utilisez Decompiler comme seconde vue lisible. Confirmez les offsets des champs et les cibles des pointeurs dans Listing et dans les octets sous-jacents.
DÉPANNAGE

Corriger les tailles, offsets et vues de types obsolètes — types de données Ghidra

Lorsqu’un type semble faux, commencez par le plus petit désaccord. Vérifiez le langage processeur, l’espace d’adressage, l’ordre des octets, la plage sélectionnée et la signature de fonction avant de changer plusieurs champs. Un pointeur 64 bits appliqué à une table 32 bits, ou une structure packée appliquée à des données naturellement alignées, peut rendre tous les accès suivants incohérents. Annulez la dernière modification, comparez les octets et retestez une seule hypothèse.

Une vue Decompiler obsolète peut également induire en erreur. Laissez l’analyse en arrière-plan se terminer, actualisez ou resélectionnez la fonction et vérifiez que Listing et Decompiler pointent vers la même adresse. Si une archive fournit un nom similaire, inspectez sa taille et son packing au lieu de supposer la compatibilité. Comparez encore les types lorsqu’un appelant diverge et gardez une copie du projet avant les grandes modifications.

Conservez la trace de l’erreur — types de données Ghidra

Notez l’adresse exacte, le type, le langage et la modification qui ont créé le problème. Une courte note avant/après est plus utile que de deviner sans cesse une nouvelle structure.

SymptômeVérifier d’abordAction suivante plus sûre
Fields shift after applying a structureField sizes, padding, and languageUndo, keep the gap undefined, and rebuild from offsets
Pointer points outside memoryAddress space, base, and pointer widthTreat it as an integer until a valid target is found
Decompiler shows many castsSignature, signedness, and target typeVerify one caller and one load/store in Listing
Array consumes unrelated bytesCount, stride, and terminationUse a shorter count or a runtime boundary
Type is missing from the managerCategory, archive path, and filterRefresh and import only a verified archive
LISTE DE CONTRÔLE

Un flux de travail reproductible pour les types de données Ghidra

Une session de modélisation fiable est petite, explicite et facile à relire. Commencez par un indice tel qu’un offset répété, une longueur connue, un déréférencement ou une comparaison constante. Notez l’adresse et les octets, choisissez le type le plus étroit qui explique l’indice et vérifiez le résultat dans Listing avant d’ajouter des noms. Passez seulement ensuite à une structure, un tableau, une énumération ou un pointeur qui combine plusieurs observations confirmées.

Pour une équipe ou une enquête répétée, conservez la version du projet, le langage processeur, la source du type et le niveau de confiance de chaque définition importante. Séparez les types du programme des imports d’archives spéculatifs et comparez les types lorsqu’un appelant diverge. Utilisez le guide Script Manager seulement après avoir compris l’opération manuelle. Un script reproduit vite un bon modèle, mais propage tout aussi vite une mauvaise hypothèse.

Le but n’est pas de faire ressembler chaque ligne à du code source. Il s’agit d’un modèle qui explique les octets, les références et le flux de contrôle tout en montrant ce qui reste inconnu. Gardez les types, les offsets et les cibles de pointeurs vérifiables afin que l’analyste suivant puisse tester, réviser ou automatiser l’interprétation.

  1. 1

    Ancrer — types de données Ghidra

    Start from an address, reference, loop bound, or repeated access that you can point to in Listing.

    evidence -> address
  2. 2

    Modéliser — types de données Ghidra

    Apply the smallest primitive or field type that explains the observed width and representation.

    address -> type
  3. 3

    Vérifier — types de données Ghidra

    Compare bytes, offsets, references, and one Decompiler consumer before adding names or padding.

    Listing -> Decompiler
  4. 4

    Préserver — types de données Ghidra

    Save a project copy and record the reason, confidence, and reversal path for the model.

    type + evidence + rollback
  • Use authorized binaries and keep original files unchanged.
  • Separate file offsets, loaded addresses, and pointer targets in notes.
  • Prefer visible uncertainty over a field or count that is only a guess.
  • Re-check callers after changing a structure or function signature.
  • Automate only after one manual example is correct and repeatable.
FAQ

Questions sur les types de données Ghidra

À quoi servent les types de données Ghidra ?

Les types de données Ghidra décrivent l’affichage et l’interprétation des octets dans le modèle du programme. Ils permettent de définir primitifs, chaînes, structures, tableaux, énumérations et pointeurs, puis de vérifier ces définitions dans Listing et Decompiler.

Comment créer une structure dans Ghidra ?

Ouvrez Data Type Manager, créez une structure dans la catégorie du programme courant, ajoutez les champs dans l’ordre des offsets, laissez les intervalles non prouvés indéfinis ou justifiés par un padding, puis appliquez la structure à son adresse de base dans Listing.

Pourquoi les champs de ma structure Ghidra ont-ils de mauvais offsets ?

Vérifiez le langage processeur, la taille des champs, l’alignement, le packing et tout padding explicite. Annulez la définition, comparez les octets d’origine et reconstruisez la plus petite structure soutenue par des accès répétés.

Dois-je définir un type de pointeur dans Ghidra ?

Définissez un pointeur lorsque la valeur sert d’adresse et qu’au moins une référence confirme son espace d’adressage et sa cible. Sans cette preuve, gardez une valeur entière ou un type de taille inconnue jusqu’à la vérification de la cible.

Un type de données Ghidra peut-il modifier le binaire original ?

Appliquer un type de données modifie le modèle du projet et ses vues, pas le fichier d’entrée original. Gardez une copie du projet et exportez des notes lors des grandes modifications de modélisation.

Pourquoi Decompiler affiche-t-il encore des valeurs indéfinies après l’application d’un type ?

Resélectionnez la fonction et laissez l’analyse se terminer, puis confirmez que le type a été appliqué à l’adresse réellement lue par la fonction. Une mauvaise signature, profondeur de pointeur ou carte mémoire peut maintenir les casts et les valeurs indéfinies dans le pseudo-code.