NOME

       bzero, explicit_bzero - zera uma string de bytes

BIBLIOTECA

       Biblioteca C Padrão (libc, -lc)

SINOPSE

       #include <strings.h>

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

       #include <string.h>

       void explicit_bzero(void s[.n], 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 │
       └───────────────────────────────────────────────────────────────┴───────────────┴─────────┘

PADRÕES

       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:

       •  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.

       •  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)

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