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

Linux                                             6 março 2019                                          BZERO(3)