Se quiser adicionar hosts personalizados ou uma lista de permissões, crie um ou ambos os ficheiros
conforme [as instruções](#how-do-i-control-which-sources-are-unified) e adicione os
seguintes argumentos _antes_ de `ghcr.io/stevenblack/hosts:latest` consoante
o que pretender utilizar.```sh
-v "path/to/myhosts:/hosts/myhosts" \
-v "path/to/whitelist:/hosts/whitelist" \

Ou sem clonar (diretamente do GitHub):```sh
docker build --no-cache https://github.com/StevenBlack/hosts.git -t stevenblack-hosts

docker run --rm -it stevenblack-hosts updateHostsFile.py
```
> Isso criará o arquivo hosts e o removerá com o contêiner quando terminar,
> portanto não é muito útil. Você pode usar o exemplo da opção #1 para adicionar volumes, de modo que
> os arquivos no seu host sejam substituídos.

### Opção 3: Gerar no seu próprio ambiente

Para gerar seus próprios arquivos hosts mesclados, você precisará do Python 3.6 ou posterior.

Primeiro, instale as dependências com:```sh
pip3 install --user -r requirements.txt
```
**Nota** recomendamos o uso da flag `--user`, que instala as dependências necessárias
no nível do usuário. Mais informações sobre ela podem ser encontradas na
[documentação](https://pip.pypa.io/en/stable/reference/pip_install/?highlight=--user#cmdoption-user) do pip.

### Opção 4: Gerar no Google Colab

Inicie um ambiente remoto gratuito do [Google Colab](https://colab.research.google.com/drive/1tYWXpU2iuPDqN_o03JW9ml3ExO80eBLq?usp=sharing).

### Etapas comuns independentemente do seu ambiente de desenvolvimento

Para **executar testes unitários**, no diretório de nível superior, execute:```sh
python3 testUpdateHostsFile.py
```
O script `updateHostsFile.py` gerará um arquivo hosts unificado com base nas
fontes da subpasta local `data/`. O script perguntará se você deseja
buscar versões atualizadas (a partir de locais definidos pelo arquivo de texto
`update.json` na pasta de cada fonte). Caso contrário, ele usará o arquivo
`hosts` que já está lá.```sh
python3 updateHostsFile.py [--auto] [--replace] [--ip nnn.nnn.nnn.nnn] [--extensions ext1 ext2 ext3]
```
#### Opções de linha de comando

`--help`, ou `-h`: exibe a ajuda.

`--auto`, ou `-a`: executa o script sem solicitações. Quando `--auto` é invocado,

- As fontes de dados de hosts, incluindo extensões, são atualizadas.
- Nenhuma extensão é incluída por padrão. Use a flag `--extensions` ou `-e` para
  incluir as que desejar.
- Seu arquivo hosts ativo _não_ é substituído a menos que você inclua a flag
  `--replace`.

`--backup`, ou `-b`: Cria um backup dos arquivos hosts existentes ao gerar
sobre eles.

`--extensions <ext1> <ext2> <ext3>`, ou `-e <ext1> <ext2> <ext3>`: os nomes das
subpastas abaixo da pasta `extensions` que contêm arquivos hosts adicionais
específicos de categoria para incluir na amálgama. Exemplo: `--extensions porn`
ou `-e social porn`.

`--flush-dns-cache`, ou `-f`: pula a solicitação para limpar o cache de DNS. Só
fica ativo quando `--replace` também está ativo.

`--ip nnn.nnn.nnn.nnn`, ou `-i nnn.nnn.nnn.nnn`: o endereço IP a ser usado como
alvo. O padrão é `0.0.0.0`.

`--keepdomaincomments`, ou `-k`: `true` (padrão) ou `false`, mantém os
comentários que aparecem na mesma linha dos domínios. O padrão é `true`.

`--noupdate`, ou `-n`: pula a busca de atualizações das fontes de dados de hosts.

`--output <subfolder>`, ou `-o <subfolder>`: coloca o arquivo de origem gerado
em uma subpasta. Se a subpasta não existir, ela será criada.

`--replace`, ou `-r`: aciona a substituição do seu arquivo hosts ativo

`--skipstatichosts`, ou `-s`: `false` (padrão) ou `true`, omite a seção padrão
no topo, contendo linhas como `127.0.0.1 localhost`. Isso é útil para configurar
serviços DNS locais na rede local.

`--nogendata`, ou `-g`: `false` (padrão) ou `true`, pula a geração do arquivo
readmeData.json usado para gerar arquivos readme.md. Isso é útil se você estiver
gerando arquivos hosts com whitelists ou blacklists adicionais e quiser manter
seu checkout local deste repositório inalterado.

`--nounifiedhosts`: `false` (padrão) ou `true`, não inclui o arquivo hosts
unificado no arquivo hosts final. Geralmente usado junto com `--extensions`.

`--compress`, ou `-c`: `false` (padrão) ou `true`, _Comprime_ o arquivo hosts
ignorando linhas desnecessárias (linhas vazias e comentários) e colocando vários
domínios em cada linha. Reduzir o número de linhas do arquivo hosts melhora o
desempenho no Windows (com o serviço DNS Client habilitado).

`--minimise`, ou `-m`: `false` (padrão) ou `true`, como `--compress`, mas coloca
cada domínio em uma linha separada. Isso é necessário porque muitas
implementações de bloqueadores de URL que dependem de arquivos `hosts` não estão
em conformidade com o padrão que permite vários hosts em uma única linha.

`--blacklist <blacklistfile>`, ou `-x <blacklistfile>`: Acrescenta o arquivo
blacklist fornecido no formato hosts ao arquivo hosts gerado.

`--whitelist <whitelistfile>`, ou `-w <whitelistfile>`: Usa o arquivo whitelist
fornecido para remover hosts do arquivo hosts gerado.

## Como controlo quais fontes são unificadas?

Adicione uma ou mais fontes _adicionais_, cada uma em uma subpasta da pasta
`data/`, e especifique a chave `url` no arquivo `update.json` correspondente.

Adicione uma ou mais extensões _opcionais_, que se originam de subpastas da
pasta `extensions/`. Novamente, a url em `update.json` controla onde esta
extensão encontra suas atualizações.

Crie um arquivo `blacklist` _opcional_. O conteúdo deste arquivo (contendo uma
listagem de domínios adicionais no formato de arquivo `hosts`) é anexado ao
arquivo hosts unificado durante o processo de atualização. Um exemplo de
`blacklist` está incluído e pode ser modificado conforme necessário.

- NOTA: O `blacklist` não é rastreado pelo git, portanto, quaisquer alterações
  que você fizer não serão sobrescritas quando você executar `git pull` deste
  repositório a partir do `origin` no futuro.

### Como incluo meus próprios mapeamentos de domínio personalizados?

Se você tiver registros de hosts personalizados, coloque-os no arquivo `myhosts`.
O conteúdo deste arquivo é prefixado ao arquivo hosts unificado durante o
processo de atualização.

O arquivo `myhosts` não é rastreado pelo git, portanto, quaisquer alterações que
você fizer não serão sobrescritas quando você executar `git pull` deste
repositório a partir do `origin` no futuro.

### Como evito que domínios sejam incluídos?

Os domínios que você lista no arquivo `whitelist` são excluídos do arquivo hosts
final.

O `whitelist` usa correspondência parcial. Portanto, se você incluir
`google-analytics.com` na whitelist, esse domínio e todos os seus subdomínios
não serão mesclados no arquivo hosts final.

O `whitelist` não é rastreado pelo git, portanto, quaisquer alterações que você
fizer não serão sobrescritas quando você executar `git pull` deste repositório
a partir do `origin` no futuro.

## Como posso contribuir com registros de hosts?

Se você descobrir domínios suspeitos que acha que deveriam ser incluídos aqui,
aqui estão algumas maneiras de contribuir com eles.

### Opção 1: entre em contato com uma de nossas fontes de hosts

A melhor maneira de incluir novos domínios é enviar uma issue para qualquer um
dos provedores de dados cujas páginas iniciais estão
[listadas aqui](https://github.com/StevenBlack/hosts#sources-of-hosts-data-unified-in-this-variant).
Isso é o melhor porque, depois que você enviar novos domínios, eles serão
curados e atualizados pelas pessoas dedicadas que mantêm essas fontes.

### Opção 2: Faça um fork deste repositório, adicione seus domínios ao arquivo de dados pessoal de Steven Black e envie um pull request

Faça um fork deste repositório de hosts e adicione seus links a
[https://github.com/StevenBlack/hosts/blob/master/data/StevenBlack/hosts](https://github.com/StevenBlack/hosts/blob/master/data/StevenBlack/hosts).

Depois, envie um pull request.

**AVISO**: isso é menos desejável do que a Opção 1 porque a curadoria contínua
recai sobre nós. Portanto, isso gera mais trabalho para nós.

### Opção 3: crie sua própria lista de hosts como um repositório no GitHub

Se você puder selecionar sua própria coleção de domínios suspeitos, crie sua
própria lista de hosts. Em seguida, sinalize a existência do seu repositório
como
[uma nova issue](https://github.com/StevenBlack/hosts/issues) e poderemos incluir
seu novo repositório na coleção de fontes que usamos sempre que criamos novas
versões.

## O que é um arquivo hosts?

Um arquivo hosts, chamado `hosts` (sem extensão de arquivo), é um arquivo de
texto simples usado por todos os sistemas operacionais para mapear nomes de host
para endereços IP.

Na maioria dos sistemas operacionais, o arquivo `hosts` tem precedência sobre o
`DNS`. Portanto, se um nome de domínio for resolvido pelo arquivo `hosts`, a
solicitação nunca sai do seu computador.

Ter um arquivo `hosts` inteligente ajuda muito a bloquear malware, adware e
outros incômodos.

Por exemplo, para anular solicitações a alguns servidores doubleclick.net,
adicionar estas linhas ao seu arquivo hosts resolve:```text
# block doubleClick's servers
0.0.0.0 ad.ae.doubleclick.net
0.0.0.0 ad.ar.doubleclick.net
0.0.0.0 ad.at.doubleclick.net
0.0.0.0 ad.au.doubleclick.net
0.0.0.0 ad.be.doubleclick.net
# etc...
```
## Recomendamos usar `0.0.0.0` em vez de `127.0.0.1`

Tradicionalmente, a maioria dos arquivos de hosts usa `127.0.0.1`, o _endereço de loopback_, para
estabelecer uma conexão IP com a máquina local.

Preferimos usar `0.0.0.0`, que é definido como um meta-endereço não roteável usado
para designar um destino inválido, desconhecido ou não aplicável.

Usar `0.0.0.0` é empiricamente mais rápido, possivelmente porque não há espera por uma
resolução de timeout. Também não interfere com um servidor web que possa estar
em execução no PC local.

## Por que não usar `0` em vez de `0.0.0.0`?

Tentamos isso. Usar `0` não funciona universalmente.

## Localização do seu arquivo de hosts

Para modificar seu arquivo `hosts` atual, procure-o nos seguintes locais e
modifique-o com um editor de texto.

- **macOS (até 10.14.x macOS Mojave), iOS, Android, Linux**: o arquivo
  `/etc/hosts`.
- **macOS Catalina:** o arquivo `/private/etc/hosts`.
- **Windows**: o arquivo `%SystemRoot%\system32\drivers\etc\hosts`.

## Gentoo

Usuários do Gentoo podem encontrar
[`sb-hosts`](https://github.com/PF4Public/gentoo-overlay/tree/master/net-misc/sb-hosts)
no overlay Gentoo [::pf4public](https://github.com/PF4Public/gentoo-overlay)

## NixOS

Para instalar o arquivo de hosts na sua máquina, adicione o seguinte ao seu
`configuration.nix`:```nix
{
  networking.extraHosts = let
    hostsPath = https://raw.githubusercontent.com/StevenBlack/hosts/master/hosts;
    hostsFile = builtins.fetchurl hostsPath;
  in builtins.readFile "${hostsFile}";
}
```
- NOTA: Altere `hostsPath` se precisar de outras versões do arquivo hosts.
- NOTA: A chamada a `fetchurl` é impura. Use `fetchFromGitHub` com o commit exato
  se quiser sempre obter o mesmo resultado.

### Nix Flake

Instalações NixOS que são gerenciadas por meio de _flakes_ podem usar diretamente o `flake.nix` neste repositório como uma entrada.

Ele contém um `nixosModule` que pode ser usado para instalar o arquivo `hosts` localmente, bem como um pacote contendo arquivos de configuração para o servidor DNS [Unbound](https://github.com/NLnetLabs/unbound) para ser usado como listas de bloqueio.```nix
{
  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs?ref=$YOUR-REF";
    hosts = {
      url = "github:StevenBlack/hosts"; # or a fork/mirror
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };

  outputs = { self, nixpkgs, hosts }: {
    nixosConfigurations.my-hostname = {
      system = "<architecture>";
      modules = [
        # nixosModule to install hosts file locally:
        hosts.nixosModule
        {
          networking.stevenBlackHosts = {
            enable = true;
            # optionally:
            # enableIPv6 = true;
            # blockFakenews = true;
            # blockGambling = true;
            # blockPorn = true;
            # blockSocial = true;
          };
        }

        # configure unbound to use config as blocklist:
        {
          {
            services.unbound = {
              enable = true;
              settings.server.include = [
                "${hosts.packages.${system}.unbound}/hosts"
                # alternates are also available, e.g. /fakenews, /fakenews-gambling etc.
              ];
            };
          }
        }
      ];
    };
  };
}
```
## Atualizando o arquivo hosts no Windows

(NOTA: Veja também alguns gerenciadores de Hosts de terceiros, listados abaixo.)

### Para versões mais antigas do Windows

No Linux e no macOS, execute o script Python. No Windows é necessário mais trabalho devido
a problemas de compatibilidade, então é preferível executar o arquivo batch da seguinte forma:```sh
updateHostsWindows.bat
```
This file **MUST** be run in command prompt with administrator privileges in the
repository directory. In addition to updating the hosts file, it can also
replace the existing hosts file, and reload the DNS cache. It goes without
saying that for this to work, you must be connected to the internet.

To open a command prompt as administrator in the repository's directory, do the
following:

- **Windows XP**: Start → Run → `cmd`
- **Windows Vista, 7**: Start Button → type `cmd` → right-click Command Prompt →
  "Run as Administrator"
- **Windows 8**: Start → Swipe Up → All Apps → Windows System → right-click
  Command Prompt → "Run as Administrator"
- **Windows 10**: Start Button → type `cmd` → right-click Command Prompt → "Run
  as Administrator"

### For new versions of Windows

On modern versions of Windows (10 and especially 11) not all features of the
aforementioned batch script work (specifically checking if the current shell has
administrative priviliges) and therefore a more modern approach is recommended.

The provided `updateHostsWindows.ps1` is a Powershell 5.1 script that does the
same thing as the batch script, but without the need for the python script, with
added options, and uses only built-in commands (self-contained). As with the
batch file it **MUST** be ran with administrative privildges, but it can
relaunch itself if not.

To run execute the script type:```Powershell
.\updateHostsWindows.ps1
```
em qualquer linha de comando do Windows disponível e, para informações detalhadas, digite:```Powershell
Get-Help .\updateHostsWindows.ps1 -Full
```
Novos Windows vêm com vários problemas (que podem ser superados) e para mais
informações e soluções, visite a página inicial deste script [aqui](https://github.com/Lateralus138/updateHostsWindows-stevenblack).

---

Você também pode consultar a seção "Third-Party Hosts Managers" para mais
soluções recomendadas por terceiros.

### Aviso: Usar este arquivo `hosts` no Windows pode exigir a desativação do serviço de Cache de DNS

O Windows tem problemas com arquivos hosts maiores. Alterações recentes na segurança do
Windows 10 negam o acesso à alteração de serviços por meio de outras ferramentas, exceto
modificações no registro. Use o arquivo `disable-dnscache-service-win.cmd` para fazer as
alterações adequadas no registro do Windows. Você precisará reiniciar o dispositivo depois
que isso for feito. Veja os
[comentários dentro do arquivo `cmd`](https://github.com/StevenBlack/hosts/blob/master/disable-dnscache-service-win.bat)
para mais detalhes.

Desativar o serviço de Cache de DNS pode causar problemas com serviços e aplicativos como *WSL*,
e é possível compactar o arquivo hosts e eliminar a necessidade de desativar o serviço de cache DNS.
Você pode tentar a ferramenta de linha de comando do Windows em *C++* em [Hosts Compress - Windows](https://github.com/Lateralus138/hosts-compress-windows)
(o método recomendado) ou o script de compactação em *PowerShell* e conferir o guia localizado no repositório
[Hosts Compression Scripts](https://github.com/Lateralus138/hosts-compression-scripts).

## Recarregando o arquivo hosts

Seu sistema operacional armazenará em cache as consultas de DNS. Você pode reiniciar ou executar
os seguintes comandos para limpar manualmente o cache de DNS depois que o novo arquivo hosts estiver
no lugar.

O navegador Google Chrome pode exigir a limpeza manual do cache de DNS na
página `chrome://net-internals/#dns` para, a partir de então, ver as alterações no seu arquivo
hosts. Veja: <https://superuser.com/questions/723703>

### Windows

Abra um prompt de comando com privilégios de administrador e execute este comando:```bat
ipconfig /flushdns
```
### Linux

Abra um Terminal e execute com privilégios de root:

- **Debian/Ubuntu** `sudo service network-manager restart`
- **Linux Mint** `sudo /etc/init.d/dns-clean start`
- **Linux com systemd**: `sudo systemctl restart network.service`
- **Fedora Linux**: `sudo systemctl restart NetworkManager.service`
- **Arch Linux/Manjaro com Network Manager**:
  `sudo systemctl restart NetworkManager.service`
- **Arch Linux/Manjaro com Wicd**: `sudo systemctl restart wicd.service`
- **RHEL/Centos**: `sudo /etc/init.d/network restart`
- **FreeBSD**: `sudo service nscd restart`

  Para habilitar o daemon `nscd` inicialmente, é recomendado que você execute os
  seguintes comandos:  ```sh
  sudo sysrc nscd_enable="YES"
  sudo service nscd start
  ```
Em seguida, modifique a linha `hosts` no seu arquivo `/etc/nsswitch.conf` para o
  seguinte:  ```text
  hosts: cache files dns
  ```
- **NixOS**: O `nscd.service` é reiniciado automaticamente quando a opção
  `networking.extraHosts` foi alterada.
- **Outros**: Consulte
  [este artigo da Wikipédia](https://en.wikipedia.org/wiki/Hosts_%28file%29#Location_in_the_file_system).

### macOS

Conforme descrito em [este artigo](https://osxdaily.com/2022/11/21/how-clear-dns-cache-macos-ventura-monterey/),
abra um Terminal e execute:```sh
sudo dscacheutil -flushcache;sudo killall -HUP mDNSResponder
```
## Release management

Este repositório usa o [release-it](https://github.com/release-it/release-it), uma
excelente ferramenta CLI de release para repositórios GitHub e pacotes npm, para automatizar
a criação de [releases](https://github.com/StevenBlack/hosts/releases). É por isso
que os
[package.json](https://github.com/StevenBlack/hosts/blob/master/package.json)
e
[.release-it.json](https://github.com/StevenBlack/hosts/blob/master/.release-it.json)
arquivos estão incluídos.

## Objetivos deste arquivo hosts unificado

Os objetivos deste repositório são:

1. combinar automaticamente listas de hosts de alta qualidade,
2. fornecer extensões apropriadas para cada situação,
3. deduplicar a lista combinada resultante,
4. e manter o arquivo resultante com tamanho razoável.

Uma fonte de alta qualidade é definida aqui como uma que é ativamente curada. Uma fonte
de hosts deve ser atualizada com frequência por seus mantenedores, tanto com adições quanto com
remoções. Quanto maior o arquivo de hosts, maior o nível de curadoria esperado.

Espera-se que este arquivo hosts unificado atenda tanto dispositivos desktop quanto móveis sob uma variedade de sistemas operacionais.

## Gerenciadores de Hosts de Terceiros

- [Unified Hosts AutoUpdate](https://github.com/ScriptTiger/Unified-Hosts-AutoUpdate "Unified Hosts AutoUpdate")
  (para Windows): O pacote Unified Hosts AutoUpdate é feito sob medida para este
  projeto de hosts unificado e também está em desenvolvimento ativo por membros da comunidade.
  Você pode instalar e desinstalar qualquer blacklist e mantê-la automaticamente
  atualizada, e ele pode ser colocado em um local de rede compartilhado e implantado em uma
  organização por meio de políticas de grupo. E, como está em desenvolvimento ativo
  por membros da comunidade, seus relatórios de bugs, solicitações de recursos e outros comentários são
  muito bem-vindos.
- [ViHoMa](https://github.com/cmabad/ViHoMa) é um Gerenciador visual de arquivos Hosts,
  escrito em Java, por Christian Martínez. Confira!
- [SaneHosts](https://sanehosts.com "SaneHosts") (para macOS): Um gerenciador de arquivos hosts nativo com bloqueio baseado em perfis, proteção por Touch ID e suporte a mais de 200 blocklists curadas. Código aberto.

## Aplicações Interessantes

- [Hosts-BL](https://github.com/ScriptTiger/Hosts-BL "Hosts-BL") é uma ferramenta simples
  para lidar com blacklists de arquivos hosts. Ela pode remover comentários, remover
  duplicatas, compactar para 9 domínios por linha, adicionar entradas IPv6. Além disso,
  também pode converter blacklists em vários outros formatos de blacklist compatíveis
  com outros softwares, como dnsmasq, DualServer, RPZ, Privoxy e Unbound,
  para citar alguns.
- [Host Minder](https://github.com/jeremehancock/hostminder#readme) é uma GUI simples
  que permite atualizar facilmente o seu arquivo /etc/hosts para um dos quatro
  arquivos hosts consolidados do StevenBlack/hosts. Ele é fornecido como um pacote deb
  e já vem pré-instalado no [UbuntuCE](https://ubuntuce.com/).
- [Maza ad blocking](https://github.com/tanrax/maza-ad-blocking) é um script bash
  que atualiza automaticamente o arquivo hosts. Você também pode atualizar uma cópia nova.
  E a cada vez ele gera um arquivo de configuração compatível com dnsmasq. Instalação
  rápida, compatível com MacOS, Linux e BSD.
- [Hostile](https://github.com/feross/hostile) é um utilitário de linha de comando prático
  para adicionar ou remover domínios do seu arquivo hosts facilmente. Se os nossos arquivos hosts forem
  agressivos demais para você, pode usar o `hostile` para remover domínios, ou pode
  usar o `hostile` em um script bash para automatizar um pós-processamento cada vez que
  baixar versões novas de hosts.
- [macOS Scripting for Configuration, Backup and Restore](https://github.com/tiiiecherle/osx_install_config)
  ajuda a personalizar, reinstalar e usar o macOS. Ele também fornece um
  [script](https://github.com/tiiiecherle/osx_install_config/blob/master/09_launchd/9b_run_on_boot/root/1_hosts_file/launchd_and_script/hosts_file_generator.sh)
  para instalar e atualizar o arquivo hosts usando este projeto no macOS. Em
  combinação com um
  [launchd](https://github.com/tiiiecherle/osx_install_config/blob/master/09_launchd/9b_run_on_boot/root/1_hosts_file/launchd_and_script/com.hostsfile.install_update.plist)
  ele atualiza o arquivo hosts a cada x dias (o padrão é 4). Para instalar ambos,
  baixe o repositório do GitHub e execute o
  [script de instalação](https://github.com/tiiiecherle/osx_install_config/blob/master/09_launchd/9b_run_on_boot/root/1_hosts_file/install_hosts_file_generator_and_launchdservice.sh)
  a partir do diretório um nível acima.
- [Pi-hole](https://pi-hole.net/) é um servidor DHCP para toda a rede e bloqueador de anúncios
  que roda em [Raspberry Pi](https://en.wikipedia.org/wiki/Raspberry_Pi).
  O Pi-hole usa este repositório como uma de suas fontes.
- [Bloqueie anúncios e malware via servidor DNS local BIND9](https://github.com/mueller-ma/block-ads-via-dns "Bloqueie anúncios e malware via servidor DNS local")
  (para Debian, Raspbian e Ubuntu): Configure um servidor DNS local com um
  arquivo `/etc/bind/named.conf.blocked`, originado daqui.
- [Bloqueie anúncios, malware e implemente controles parentais via servidor DNS/DHCP DualServer local](https://scripttiger.github.io/dualserver/ "Bloqueie anúncios, malware e implemente controles parentais via servidor DNS/DHCP DualServer local")
  (para BSD, Windows e Linux): Configure uma blacklist para todos na sua rede
  usando o poder do hosts unificado reformatado para o DualServer. E se você
  estiver no Windows, este projeto também mantém um script de atualização para tornar
  a atualização da blacklist do DualServer ainda mais fácil.
- [Bloqueando anúncios e malwares com unbound](https://deadc0de.re/articles/unbound-blocking-ads.html "Bloqueando anúncios e malwares com unbound")
  –
  [Unbound](https://www.unbound.net/ "O Unbound é um resolvedor DNS validante, recursivo e com cache.")
  é um resolvedor DNS validante, recursivo e com cache.
- [script de conversão para dnsmasq](https://gist.github.com/erlepereira/c11f4f7a3f60cd2071e79018e895fc8a#file-dnsmasq-antimalware)
  Este gist do GitHub tem um pequeno script de shell (bash, funciona em qualquer 'nix) e
  usa `wget` e `awk` presentes na maioria das distros, para baixar um arquivo hosts específico
  e convertê-lo para o formato exigido pelo dnsmasq. Suporta IPv4 e IPv6.
  Projetado para ser usado como script de shell, ou pode ser colocado em
  `/etc/cron.weekly` (ou onde for conveniente). O script é curto e facilmente editável,
  e também vem com um pequeno documento com notas sobre a configuração do dnsmasq.
- [BlackHosts - Instalador/Atualizador de Linha de Comando](https://github.com/Lateralus138/blackhosts)
  Este é um utilitário de linha de comando multiplataforma para ajudar a instalar/atualizar arquivos
  hosts encontrados neste repositório.
- [Scripts de Compactação de Hosts](https://github.com/Lateralus138/hosts-compression-scripts) São vários scripts para ajudar a compactar arquivos hosts (pelo autor do BlackHosts).
- [Hosts Compress - Windows](https://github.com/Lateralus138/hosts-compress-windows) Esta é uma ferramenta de linha de comando para Windows em *C++* para ajudar a compactar arquivos hosts (pelo autor do BlackHosts e dos Scripts de Compactação de Hosts). Esta é altamente recomendada em vez dos scripts, pois é **exponencialmente mais rápida**.
- [dnscrypt-proxy](https://github.com/DNSCrypt/dnscrypt-proxy/wiki/Combining-Blocklists)
  fornece uma ferramenta para construir listas de bloqueio a partir de listas locais e remotas em formatos
  comuns.
- [Control D](https://controld.com/free-dns)
  oferece um espelho público hospedado em rede anycast da blocklist Unified (Adware + Malware):
  - Legacy DNS: `76.76.2.35`, `76.76.10.35`, `2606:1a40::35`, `2606:1a40:1::35`
  - DNS-over-HTTPS/TLS/DOQ: `https://freedns.controld.com/x-stevenblack`, `x-stevenblack.freedns.controld.com`

## Contribua

Por favor, leia o nosso
[Guia de Contribuição](https://github.com/StevenBlack/hosts/blob/master/contributing.md).
Entre outras coisas, ele explica como organizamos arquivos e pastas neste
repositório.

Estamos sempre interessados em descobrir fontes bem curadas de hosts. Se você
encontrar uma, abra uma [issue](https://github.com/StevenBlack/hosts/issues) para
chamar a nossa atenção.

Antes de criar ou responder a qualquer issue, leia o nosso
[código de conduta](https://github.com/StevenBlack/hosts/blob/master/code_of_conduct.md).

Logo por [@Tobaloidee](https://github.com/Tobaloidee) Obrigado!.