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).
       ┌─────────────────────────────────────────────────────────────────────────────┬───────────────┬─────────┐
       │ Interface                                                                   │ Atributo      │ Valor   │
       ├─────────────────────────────────────────────────────────────────────────────┼───────────────┼─────────┤
       │ 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 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 man-pages 6.8                                2 maio 2024                                          bzero(3)