NOME

       bzero, explicit_bzero - zera uma string de bytes

SINOPSE

       #include <strings.h>

       void bzero(void *s, size_t n);

       #include <string.h>

       void explicit_bzero(void *s, size_t n);

DESCRIÇÃO

       A  função bzero() apaga os dados nos n bytes do início da memória no local apontado por s,
       escrevendo zeros (bytes contendo '\0') naquela área.

       A função explicit_bzero() realiza a mesma tarefa que bzero(). A diferença para  bzero()  é
       que  ela garante que as organizações de compilador não vão remover a operação de apagar se
       o compilar deduzir que a operação é "desnecessária".

VALOR DE RETORNO

       Nenhum.

VERSÕES

       explicit_bzero() apareceu pela primeira vez no glibc 2.25.

ATRIBUTOS

       Para uma explicação dos termos usados nesta seção, consulte attributes(7).

       ┌───────────────────────────────────────────────────────────────┬───────────────┬─────────┐
       │Interface                                                      │ Atributo      │ Valor   │
       ├───────────────────────────────────────────────────────────────┼───────────────┼─────────┤
       │bzero(), explicit_bzero()                                      │ Thread safety │ MT-Safe │
       └───────────────────────────────────────────────────────────────┴───────────────┴─────────┘

DE ACORDO COM

       A função bzero() foi descontinuada (marcada como LEGACY em POSIX.1-2001); use memset(3) em
       programas novos. POSIX.1-2008 remove a especificação de bzero(). A função bzero() apareceu
       pela primeira vez em 4.3BSD.

       A função explicit_bzero() é uma extensão não padrão que  é  apresentada  em  alguns  BSDs.
       Outras implementações possuem uma função similar, como memset_explicit() ou memset_s().

NOTAS

       The  explicit_bzero()   function  addresses a problem that security-conscious applications
       may run into when using bzero(): if the compiler can deduce that the location to be zeroed
       will  never  again  be  touched by a correct program, then it may remove the bzero()  call
       altogether.  This is a problem if the intent of the bzero()  call was to  erase  sensitive
       data  (e.g.,  passwords)   to  prevent  the  possibility  that  the  data was leaked by an
       incorrect or compromised program.  Calls to explicit_bzero()  are never optimized away  by
       the compiler.

       A  função  explicit_bzero()  não  resolve  todos  os problemas associados com apagar dados
       sensíveis:

       1. A função explicit_bzero() não garante que os dados  confidenciais  sejam  completamente
          apagados da memória. (O mesmo acontece com bzero().) Por exemplo, pode haver cópias dos
          dados  confidenciais  em  um  registro  e  em  áreas  de  pilhas  "scratch".  A  função
          explicit_bzero() não está ciente dessas cópias e não pode apagá-las.

       2. Em algumas circunstâncias, explicit_bzero() posso diminuir a segurança. Se o compilador
          determinou que a variável que contém os dados confidenciais poderia ser otimizada  para
          ser  armazenada  em  um  registro  (porque  ela é pequena o suficiente para caber em um
          registro, e nenhuma operação além da chamada  explicit_bzero()  precisaria  executar  o
          comando  endereço  da  variável),  a chamada de explicit_bzero() força os dados a serem
          copiados do registro para um local na RAM que é imediatamente apagado (enquanto a cópia
          no  registro  permanece inalterada). O problema aqui é que é mais provável que os dados
          na RAM sejam expostos por um bug do que os dados em um registro e, portanto, a  chamada
          explicit_bzero()  cria uma breve janela de tempo em que os dados confidenciais são mais
          vulneráveis do que seriam. se nenhuma tentativa  tivesse  sido  feita  para  apagar  os
          dados.

       Observe  que  declarar  a variável sensível com o qualificador volatile não não elimina os
       problemas acima. De fato, isso os tornará piores,  pois,  por  exemplo,  pode  forçar  uma
       variável  que  de  outra  forma  seria otimizada em um registro a ser mantida na RAM (mais
       vulnerável) por toda a sua vida útil.

       Não obstante os detalhes  acima,  para  aplicativos  preocupados  com  a  segurança,  usar
       explicit_bzero()  em  vez  de  não  usá-lo  é geralmente preferível. Os desenvolvedores do
       explicit_bzero() antecipam que futuros compiladores reconheçam chamadas a explicit_bzero()
       e  tomem  medidas  para  garantir  que todas as cópias dos dados sigilosos sejam apagadas,
       incluindo cópias em registradores ou em áreas de pilhas "scratch".

VEJA TAMBÉM

       bstring(3), memset(3), swab(3)

COLOFÃO

       Esta página faz parte da versão 5.13 do projeto Linux man-pages. Uma descrição do projeto,
       informações  sobre  relatórios  de  bugs  e  a  versão mais recente desta página podem ser
       encontradas em https://www.kernel.org/doc/man-pages/.

TRADUÇÃO

       A tradução para português brasileiro desta página man foi criada por  Paulo  César  Mendes
       <drpc@ism.com.br>,   André   Luiz  Fassone  <lonely_wolf@ig.com.br>  e  Rafael  Fontenelle
       <rafaelff@gnome.org>.

       Esta tradução é uma documentação  livre;  leia  a  Licença  Pública  Geral  GNU  Versão  3
       ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩  ou  posterior  para  as condições de direitos
       autorais.  Nenhuma responsabilidade é aceita.

       Se você encontrar algum erro na tradução desta página de manual, envie um  e-mail  para  a
       lista de discussão de tradutores ⟨debian-l10n-portuguese@lists.debian.org⟩.