Indicateur balançant

Les indicateurs balançants et les indicateurs sauvages dans la programmation par ordinateur sont les indicateurs qui n'indiquent pas un objet valide du type approprié, ou à une valeur distinguée du pointeur nul dans les langues qui soutiennent ceci. Les indicateurs balançants surgissent quand un objet est supprimé ou désaffecté, sans modifier la valeur de l'indicateur, de sorte que l'indicateur indique toujours l'endroit de mémoire de la mémoire désaffectée. Pendant que le système peut réapproprier la mémoire précédemment libérée à un autre processus, si le programme original alors déréférence (maintenant) l'indicateur balançant, le comportement imprévisible de peut résulter , pendant que la mémoire peut maintenant contenir des données complètement différentes. C'est particulièrement le cas si le programme écrit des données à la mémoire dirigée par un indicateur balançant, car la corruption silencieuse des données indépendantes peut résulter, menant au subtile branche il peut être extrêmement difficile trouver que, ou cause sur table d'écoute les défauts (*NIX) de segmentation de ou les défauts généraux (Windows) de protection de . Si les données recouvertes sont des données de comptabilité employées par le distributeur de la mémoire système, la corruption peut causer des instabilités de système. Les indicateurs sauvages surgissent quand un indicateur est employé avant l'initialisation à un certain état KNOWN, qui est possible dans quelques langages de programmation. Ils montrent le même comportement erratique que les indicateurs balançants, bien qu'ils soient moins pour rester non détectés.

Cause des indicateurs balançants

Dans beaucoup de langues (en particulier le langage de programmation de C , qui assume le programmeur prendra soin de toutes les issues de conception, et par conséquent n'inclut pas plusieurs des contrôles qui sont présents dans des langues de plus haut niveau), la suppression d'un objet de la mémoire explicitement ou en détruisant l'élément de pile sur le retour ne change aucun indicateur associé. L'indicateur indique toujours l'endroit dans la mémoire où l'objet ou les données était, quoique l'objet ou les données ait été depuis supprimé et la mémoire peut maintenant être employée pour d'autres buts, créant un indicateur balançant.

Un exemple franc est montré ci-dessous : lang=" de { *cp = NULLE de char ; /*… * { char c ; cp = &c ; }/* l'endroit de mémoire, que c occupait, est libéré ici * le cp de/* ici est maintenant un indicateur balançant * } Dans ce qui précède, une solution pour éviter l'indicateur balançant est de faire à cp un pointeur nul après que le bloc intérieur soit sorti, ou autrement à la garantie que le cp ne sera pas employé encore sans davantage d'initialisation dans le code qui suit.

Une autre source fréquente de créer les indicateurs balançants est une combinaison jumbled du malloc () et la bibliothèque du free () appelle. En ce cas, un indicateur devient balançant quand le bloc de mémoire qu'il indique est libéré. Comme avec l'exemple précédent, à sens unique éviter ceci est de veiller à placer l'indicateur de nouveau à la nulle après libération de la mémoire, comme démontré ci-dessous : lang=" de inclure { carboniser le *cp = le malloc (A_CONST) ; /*… * libérer (cp) ; le cp de/* devient maintenant un indicateur balançant * cp = NULLE ; le cp de/* ne balance plus * /*… * } Pour finir, un pas de programmation commun pour créer un indicateur balançant renvoie l'adresse d'une variable locale. Puisque des variables locales sont désaffectées quand la fonction retourne, tous les indicateurs que le point aux variables locales deviendra les indicateurs balançants une fois l'élément de pile est désaffectés. lang=" de char * fonctionnel (vide) { char Ca = " ; Indicateurs et rangées - II" ; ; /*… * Ca de retour ; } Si on l'exige pour renvoyer l'adresse de ca, il devrait déclarer avec le spécificateur de stockage de static si vous voulez que le Ca maintienne sa valeur même entre les appels multiples à fonctionnel, ou il devrait être dynamiquement assigné (c. par l'intermédiaire du malloc) pour faire assigner la nouvelle mémoire (qui devrait être free'd postérieur pour éviter une fuite de mémoire).

Cause des indicateurs sauvages

Des indicateurs sauvages sont créés en omettant l'initialisation nécessaire avant la première utilisation. Ainsi, à proprement parler, chaque indicateur dans les langages de programmation qui n'imposent pas l'initialisation commence comme indicateur sauvage.

Ceci se produit le plus souvent en raison de sauter au-dessus de l'initialisation, pas en l'omettant. La plupart des compilateurs peuvent avertir à ce sujet.

Trous de sécurité impliquant balançant des indicateurs

Comme des bogues du débordement d'amortisseur de , balancer/bogues sauvages d'indicateur sont fréquemment des trous de sécurité. Par exemple, si l'indicateur est employé pour faire à un l'appel virtuel de la fonction , une adresse différente (se dirigeant probablement au code d'exploit) peut s'appeler due à l'indicateur de Vtable étant recouvert. Alternativement, si l'indicateur est employé pour écrire à la mémoire, une autre structure de données peut être corrompue. Même si la mémoire est seulement lue une fois l'indicateur devient balançant, il peut mener aux fuites de l'information (si des données intéressantes sont mises dans la prochaine structure assignée là) ou escalade de privilège (si la mémoire maintenant-inadmissible est employée dans des contrôles de sécurité).

Prévention des erreurs balançantes d'indicateur

Une technique populaire pour éviter de balancer des indicateurs est d'employer les indicateurs futés A de l'indicateur que futé emploie typiquement la référence de comptant aux objets de récupération. Quelques autres techniques incluent la méthode des pierres tombales et la méthode des Serrure-et-clefs .

Une alternative est d'employer le distributeur tenace de mémoire, qui élimine presque entièrement des erreurs balançantes d'indicateur, comme une série d'autres erreurs de mémoire (comme inadmissible et double libère).

Une autre approche est d'utiliser le collecteur d'ordures de Boehm , un collecteur d'ordures conservateur qui remplace les fonctions d'attribution standard de mémoire dans C et le C++ par un collecteur d'ordures. Cette approche élimine complètement des erreurs balançantes d'indicateur tout à fait la neutralisation libère, et en reprenant des objets par la collection d'ordures.

Dans les langues aimer Java, balançant des indicateurs ne peut pas se produire parce qu'il n'y a aucun mécanisme pour désaffecter explicitement la mémoire. En revanche, le collecteur d'ordures peut désaffecter la mémoire, mais seulement quand l'objet n'est plus accessible d'aucune référence.

Détection balançante d'indicateur

Pour exposer des erreurs balançantes d'indicateur, une technique de programmation commune est de placer des indicateurs au pointeur nul ou à une adresse inadmissible une fois que le stockage qu'ils indiquent a été libéré. Quand le pointeur nul est déréférencé (dans la plupart des langues) le programme se terminera immédiatement - il n'y a aucun potentiel pour la corruption de données ou le comportement imprévisible. Ceci facilite l'erreur de programmation étant à la base pour trouver et résoudre. Cette technique n'aide pas quand il y a les copies multiples de l'indicateur.

Quelques programmes de mise au point automatiquement recouvriront et détruiront les données qui ont été libérées, habituellement avec un modèle spécifique, tel que le 0xdeadbeef (le programme de mise au point visuel du C/C++ de Microsoft, par exemple, emploie 0xCC, 0xCD ou 0xDD selon ce qui a été libéré).

Des outils tels que le Valgrind , le Mudflap, ou le LLVM peuvent également être utilisés pour détecter des utilisations de balancer des indicateurs.

Random links: