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(),         │ Thread safety │ MT-Safe │
       │explicit_bzero() │               │         │
       └─────────────────┴───────────────┴─────────┘

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

       A  função  explicit_bzero()  resolve um problema que aplicativos preocupados com segurança
       podem encontrar ao usar bzero(): se o compilador puder deduzir que o local  a  ser  zerado
       nunca  mais  será  tocado  por  um  programa correto, poderá remover a chamada bzero() por
       completo. Esse  é  um  problema  se  a  intenção  da  chamada  bzero()  era  apagar  dados
       confidenciais (por exemplo, senhas) para evitar a possibilidade de os dados vazarem por um
       programa incorreto ou comprometido. As chamadas para explicit_bzero() nunca são otimizadas
       pelo compilador.

       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.10 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⟩.