bzero(3)                   Library Functions Manual                   bzero(3)

NUME
       bzero, explicit_bzero - aduce la zero un <?>ir de octe<?>i

BIBLIOTECA
       Biblioteca C standard (libc, -lc)

REZUMAT
       #include <strings.h>

       void bzero(void s[.n], size_t n);

       #include <string.h>

       void explicit_bzero(void s[.n], size_t n);

DESCRIERE
       Func<?>ia bzero() <?>terge datele din n octe<?>i ai memoriei incepand
       de la loca<?>ia indicata de s, prin scrierea de zerouri (octe<?>i care
       con<?>in '\0') in zona respectiva.

       Func<?>ia explicit_bzero() indepline<?>te aceea<?>i sarcina ca <?>i
       bzero(). Ea difera de bzero() prin faptul ca garanteaza ca optimizarile
       compilatorului nu vor elimina opera<?>ia de <?>tergere daca
       compilatorul deduce ca opera<?>ia ,,nu este necesara".

VALOAREA RETURNATA
       Niciuna.

ATRIBUTE
       Pentru o explica<?>ie a termenilor folosi<?>i in aceasta sec<?>iune, a
       se vedea attributes(7).

       +--------------------------------------+---------------------+---------+
       |Interfa<?>a                           | Atribut             | Valoare |
       +--------------------------------------+---------------------+---------+
       |bzero(), explicit_bzero()             | Siguran<?>a firelor | MT-Safe |
       +--------------------------------------+---------------------+---------+
STANDARDE
       Niciuna.

ISTORIC
       explicit_bzero()
              glibc 2.25.

              Func<?>ia explicit_bzero() este o extensie nestandardizata care
              este prezenta <?>i pe unele BSD-uri. Unele alte implementari au
              o func<?>ie similara, cum ar fi memset_explicit() sau
              memset_s().

       bzero()
              4.3BSD.

              Marcata ca fiind invechita ,,LEGACY" in POSIX.1-2001.  Eliminata
              in POSIX.1-2008.

NOTE
       Func<?>ia explicit_bzero() rezolva o problema cu care se pot confrunta
       aplica<?>iile preocupate de securitate atunci cand folosesc bzero():
       daca compilatorul poate deduce ca loca<?>ia care urmeaza sa fie pusa la
       zero nu va mai fi niciodata atinsa de un program corect, atunci poate
       elimina complet apelul bzero(). Aceasta este o problema daca inten<?>ia
       apelului bzero() a fost de a <?>terge date sensibile (de exemplu,
       parole) pentru a preveni posibilitatea ca datele sa fie divulgate de un
       program incorect sau compromis. Apelurile la explicit_bzero() nu sunt
       niciodata optimizate de compilator.

       Func<?>ia explicit_bzero() nu rezolva toate problemele asociate cu
       <?>tergerea datelor sensibile:

       o  Func<?>ia explicit_bzero() nu garanteaza ca datele sensibile sunt
          <?>terse complet din memorie; (acela<?>i lucru este valabil <?>i
          pentru bzero()). De exemplu, pot exista copii ale datelor sensibile
          intr-un registru <?>i in zonele de stiva ,,scratch". Func<?>ia
          explicit_bzero() nu este con<?>tienta de aceste copii <?>i nu le
          poate <?>terge.

       o  In anumite circumstan<?>e, explicit_bzero() poate diminua
          securitatea. In cazul in care compilatorul a determinat ca variabila
          care con<?>ine datele sensibile poate fi optimizata pentru a fi
          stocata intr-un registru (deoarece este suficient de mica pentru a
          incapea intr-un registru <?>i nicio alta opera<?>ie in afara de
          apelul explicit_bzero() nu ar trebui sa ia adresa variabilei),
          atunci apelul explicit_bzero() va for<?>a datele sa fie copiate din
          registru intr-o loca<?>ie din RAM care este apoi <?>tearsa imediat
          (in timp ce copia din registru ramane neafectata). Problema aici
          este ca datele din RAM sunt mai susceptibile de a fi expuse de o
          eroare decat datele dintr-un registru <?>i, astfel, apelul
          explicit_bzero() creeaza o scurta fereastra de timp in care datele
          sensibile sunt mai vulnerabile decat ar fi fost daca nu s-ar fi
          incercat <?>tergerea lor.

       Re<?>ine<?>i ca declararea variabilei sensibile cu calificativul
       volatile nu elimina problemele de mai sus. Intr-adevar, le va
       inrauta<?>i, deoarece, de exemplu, poate for<?>a o variabila care
       altfel ar fi fost optimizata intr-un registru sa fie men<?>inuta in
       schimb in RAM (mai vulnerabila) pe toata durata sa de via<?>a.

       Fara a aduce atingere detaliilor de mai sus, pentru aplica<?>iile care
       <?>in cont de securitate, utilizarea explicit_bzero() este, in general,
       preferabila in locul neutilizarii sale. Dezvoltatorii explicit_bzero()
       anticipeaza ca viitoarele compilatoare vor recunoa<?>te apelurile la
       explicit_bzero() <?>i vor lua masuri pentru a se asigura ca toate
       copiile datelor sensibile sunt <?>terse, inclusiv copiile din registre
       sau din zonele de stiva ,,scratch".

CONSULTA<?>I <?>I
       bstring(3), memset(3), swab(3)

TRADUCERE
       Traducerea in limba romana a acestui manual a fost facuta de Remus-
       Gabriel Chelu <remusgabriel.chelu@disroot.org>

       Aceasta traducere este documenta<?>ie gratuita; citi<?>i Licen<?>a
       publica generala GNU Versiunea 3
       <https://www.gnu.org/licenses/gpl-3.0.html> sau o versiune ulterioara
       cu privire la condi<?>ii privind drepturile de autor.  NU se asuma
       NICIO RESPONSABILITATE.

       Daca gasi<?>i erori in traducerea acestui manual, va rugam sa
       trimite<?>i un e-mail la <translation-team-ro@lists.sourceforge.net>.

Pagini de manual de Linux 6.06 31 octombrie 2023                      bzero(3)