oracular (3) explicit_bzero.3.gz

Provided by: manpages-pt-br-dev_4.23.1-1_all bug

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.

ATRIBUTOS

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

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

PADRÕES

       Nenhum.

HISTÓRICO

       explicit_bzero()
              glibc 2.25.

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

       bzero()
              4.3BSD.

              Marked as LEGACY in POSIX.1-2001.  Removed in POSIX.1-2008.

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