bzero(3) Library Functions Manual bzero(3) NOM bzero, explicit_bzero - mise a zero d'une chaine d'octets BIBLIOTHEQUE Bibliotheque C standard (libc, -lc) SYNOPSIS #include void bzero(void s[.n], size_t n); #include void explicit_bzero(void s[.n], size_t n); DESCRIPTION La fonction bzero() efface les donnees dans les n premiers octets de la memoire a partir de l'emplacement pointe par s en ecrivant des zeros (octets contenant << \0 >>) dans cette zone. La fonction explicit_bzero() execute les memes taches que bzero(). Elle differe de bzero() en ce qu'elle garantit que les optimisations du compilateur ne suppriment pas l'operation d'effacement si le compilateur deduit que l'operation n'est << pas indispensable >>. VALEUR RENVOYEE Aucune. ATTRIBUTS Pour une explication des termes utilises dans cette section, consulter attributes(7). +---------------------------------+--------------------------+---------+ |Interface | Attribut | Valeur | +---------------------------------+--------------------------+---------+ |bzero(), explicit_bzero() | Securite des threads | MT-Safe | +---------------------------------+--------------------------+---------+ STANDARDS Aucune. HISTORIQUE explicit_bzero() glibc 2.25. La fonction explicit_bzero() est une extension qui n'est pas standard, mais est presente egalement dans certains BSD. Certaines autres implementations ont une fonction similaire comme memset_explicit() ou memset_s(). bzero() 4.3BSD. Fonction marquee << LEGACY >> dans POSIX.1-2001, supprimee dans POSIX.1-2008. NOTES La fonction explicit_bzero() traite d'un probleme que peuvent rencontrer les applications soucieuses de la securite lors de l'utilisation de bzero() : si le compilateur peut deduire que l'emplacement a mettre a zero ne sera jamais plus touche par un programme correct, alors il peut supprimer completement l'appel bzero(). C'est un probleme si l'intention de l'appel bzero() etait d'effacer des donnees sensibles (par exemple des mots de passe) pour eviter la possibilite de la divulgation des donnees par un programme incorrect ou compromis. Les appels a explicit_bzero() ne sont jamais optimises par le compilateur. La fonction explicit_bzero() ne resout pas tous les problemes associes a l'effacement des donnees sensibles : - La fonction explicit_bzero() ne garantit pas que les donnees sensibles sont completement effacees de la memoire. (C'est la meme chose pour bzero().) Par exemple, il peut y avoir des copies des donnees sensibles dans un registre et des zones << scratch >> de la pile. La fonction explicit_bzero() n'a pas connaissance de ces copies et ne peut pas les effacer. - Dans certaines circonstances, explicit_bzero() peut reduire la securite. Si le compilateur a determine que la variable contenant les donnees sensibles pouvait etre optimisee pour etre stockee dans un registre (parce qu'elle etait assez petite pour tenir dans un registre et qu'aucune autre operation que l'appel explicit_bzero() n'avait besoin d'obtenir l'adresse de la variable), alors l'appel explicit_bzero() pourra forcer la copie des donnees du registre vers un emplacement en memoire vive qui est alors immediatement efface (tandis que la copie dans le registre demeure non touchee). Le probleme ici est que la donnee en memoire vive est plus susceptible d'etre exposee par un bogue que les donnees dans le registre, et donc l'appel explicit_bzero() cree une courte fenetre temporelle ou les donnees sont plus vulnerables qu'elles ne l'auraient ete si aucune tentative d'effacement des donnees n'avait ete entreprise. Notez que declarer la variable sensible avec le qualificatif de volatile n'elimine pas les probleme ci-dessus. En fait, cela ne fait que l'aggraver dans la mesure ou, par exemple, cela peut faire qu'une variable, qui autrement aurait ete optimisee dans un registre, est plutot maintenue en memoire vive (plus vulnerable) durant toute son existence. Malgre les details ci-dessus, pour les applications soucieuses de la securite, utiliser explicit_bzero() est generalement preferable a ne pas le faire. Les developpeurs d'explicit_bzero() s'attendent a ce que les compilateurs a venir reconnaitront les appels d'explicit_bzero() et prendront des mesures pour s'assurer que toutes les copies des donnees sensibles sont effacees, y compris les copies dans les registres ou dans les zones << scratch >> de la pile. VOIR AUSSI bstring(3), memset(3), swab(3) TRADUCTION La traduction francaise de cette page de manuel a ete creee par Christophe Blaess , Stephan Rafin , Thierry Vignaud , Francois Micaux, Alain Portal , Jean-Philippe Guerard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas Francois , Florentin Duneau , Simon Paillard , Denis Barbier , David Prevot , Frederic Hantrais et Jean- Pierre Giraud Cette traduction est une documentation libre ; veuillez vous reporter a la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITE LEGALE. Si vous decouvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message a . Pages du manuel de Linux 6.06 31 octobre 2023 bzero(3)