bzero

BZERO(3)                 Manual do Programador do Linux                 BZERO(3)



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

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



Linux                             22 março 2021                         BZERO(3)