# Bloquear país no site: Apache, NGINX e LiteSpeed

Instalação do GeoLite2, regra por código ISO no Apache, NGINX e LiteSpeed, a lista de exceções que não pode cair e a reversão em um comando.

> o bloqueio por país na camada HTTP é feito em três etapas: instalar o banco GeoLite2 em MMDB, expor o código ISO do país como variável do servidor web (mod_maxminddb, geoip2 ou GeoIP do LiteSpeed) e negar com 403, sempre depois de alguns dias em modo somente-log.

João Rizzon · 2026-11-01 · Infraestrutura web

---

## O que acontece no servidor quando você bloqueia por país

Bloqueio por país é uma decisão tomada em duas etapas dentro do servidor web. Primeiro o módulo de GeoIP resolve o IP de origem da requisição contra um banco local da MaxMind e exporta uma variável com o código ISO 3166-1 alpha-2 do país. Depois uma regra de acesso compara essa variável e decide entre servir, retornar 403 ou só registrar.

Isso não é firewall. O pacote chega, o TCP e o TLS completam, o servidor processa o request e só então nega. A vantagem é que você tem contexto de aplicação: dá para isentar `/.well-known/acme-challenge/`, isentar um endpoint de webhook e manter o resto fechado. A desvantagem é custo por requisição e o fato de que uma inundação volumétrica continua consumindo conexão. Quem quer cortar antes do handshake usa ipset/nftables, e aí perde a granularidade por path.

No LiteSpeed sob cPanel, a documentação oficial descreve o caminho: habilitar GeoIP no servidor web e usar as variáveis de ambiente expostas para as regras de acesso, com os bancos GeoLite2 em formato MMDB ([docs.litespeedtech.com](https://docs.litespeedtech.com/lsws/cp/cpanel/geoip/)). O raciocínio é o mesmo no Apache com `mod_maxminddb` e no NGINX com o módulo `ngx_http_geoip2_module`: módulo lê banco MMDB, módulo exporta variável, regra lê variável.

## Qual módulo usar em cada servidor e onde fica o banco MMDB

O formato legado GeoIP (.dat) está descontinuado. Trabalhe com MMDB e `geoipupdate`, que é o cliente oficial da MaxMind e exige uma conta gratuita com `AccountID` e `LicenseKey`.

| Servidor | Módulo | Variável típica de país | Onde a regra mora |
|---|---|---|---||
| Apache 2.4 | `mod_maxminddb` | `MM_COUNTRY_CODE` (você define o nome) | `<Directory>`, vhost ou `.htaccess` |
| LiteSpeed / OpenLiteSpeed | GeoIP nativo do servidor | `GEOIP_COUNTRY_CODE` | config do servidor e regras `.htaccess` compatíveis |
| NGINX | `ngx_http_geoip2_module` | `$geoip2_country_iso` (você define) | `http`/`server`/`location` |

No LiteSpeed em cPanel, a ativação é feita na configuração do servidor web e o banco é apontado por caminho de arquivo; a documentação oficial mostra o parâmetro de DB e a variável resultante, `GEOIP_COUNTRY_CODE` ([docs.litespeedtech.com](https://docs.litespeedtech.com/lsws/cp/cpanel/geoip/)). Regra que lê variável vazia nunca casa e você conclui errado que "o bloqueio não funciona": valide a variável no log antes de negar.

### Instalar o geoipupdate e baixar o GeoLite2-Country

```bash
# /etc/GeoIP.conf
AccountID 000000
LicenseKey SUA_CHAVE
EditionIDs GeoLite2-Country GeoLite2-City
DatabaseDirectory /usr/share/GeoIP

# primeira carga
geoipupdate -v
ls -l /usr/share/GeoIP/GeoLite2-Country.mmdb
```

Coloque o `geoipupdate` em cron. A MaxMind publica novas versões do GeoLite2 com regularidade; banco parado envelhece e começa a classificar faixas recém-transferidas no país errado. Um `0 4 * * 2,5 /usr/bin/geoipupdate` cobre bem sem martelar o endpoint.

### Confirmar que o módulo resolve o país antes de escrever qualquer regra

```bash
# teste do banco, independente do servidor web
mmdblookup --file /usr/share/GeoIP/GeoLite2-Country.mmdb \
  --ip 8.8.8.8 country iso_code

# teste do servidor web: exponha o país num header de resposta, temporariamente
# NGINX:  add_header X-Geo $geoip2_country_iso always;
# Apache: Header always set X-Geo "%{GEO_COUNTRY}e"
curl -sS -o /dev/null -D - https://exemplo.com.br/ | grep -i '^x-geo:'
```

Se o `mmdblookup` responde e o servidor web não, o problema é módulo ou caminho, não banco.

## Rode a regra em modo somente-log por alguns dias

Esta é a parte que separa um bloqueio que funciona de um incidente de sábado. Ligue a resolução de país, grave o código ISO no access_log, deixe alguns dias rodando e só depois negue. Você vai descobrir tráfego legítimo que não imaginava: um parceiro com saída em outro país, um monitor externo, um cliente usando VPN corporativa.

### Como gravar o código do país no access_log

Apache:

```apache
LogFormat "%h %{GEO_COUNTRY}e %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" geocombined
CustomLog /var/log/apache2/access.log geocombined
```

NGINX:

```nginx
log_format geocombined '$remote_addr $geoip2_country_iso - $remote_user [$time_local] '
                       '"$request" $status $body_bytes_sent '
                       '"$http_referer" "$http_user_agent"';
access_log /var/log/nginx/access.log geocombined;
```

### Contar hits por país e separar scanner de visitante real

```bash
# segundo campo do formato acima
awk '{print $2}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head -20

# só o que voltou 200, para separar varredura de tráfego real
# no geocombined acima, [$time_local] ocupa dois campos ($5 e $6)
# e "$request" ocupa três ($7 método, $8 path, $9 protocolo): status é $10
awk '$10==200 {print $2}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head -20

# o que cada país estrangeiro pediu, para ver se é scanner
awk '$2!="BR" {print $2, $8}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head -40
```

Ajuste os índices de campo ao seu `LogFormat`. Vale olhar duas coisas antes de decidir: pedidos com status 200 vindos de fora (candidatos a falso positivo) e pedidos a `/wp-login.php`, `/xmlrpc.php`, `/.env`, `/vendor/phpunit/` (candidatos a bloqueio sem dó).

## Allowlist ou denylist: escolher a política e escrever a regra

Duas políticas possíveis. **Allowlist** (só BR passa) é mais segura contra varredura e mais perigosa contra falso positivo. **Denylist** (bloqueia uma lista) é o oposto. Para loja que só vende no Brasil, allowlist com exceções bem escritas costuma ser o caminho; para site institucional com público disperso, denylist.

### Bloqueio no Apache com mod_maxminddb

```apache
MaxMindDBEnable On
MaxMindDBFile COUNTRY_DB /usr/share/GeoIP/GeoLite2-Country.mmdb
MaxMindDBEnv GEO_COUNTRY COUNTRY_DB/country/iso_code

<Location "/">
  <RequireAll>
    Require expr %{ENV:GEO_COUNTRY} == 'BR'
  </RequireAll>
</Location>

# exceção: ACME e webhooks passam de qualquer país
<LocationMatch "^/(\.well-known/acme-challenge/|webhooks/)">
  Require all granted
</LocationMatch>
```

Variável vazia (IP não encontrado no banco, IP privado, bogon) não é igual a `BR` e cai no 403. Decida conscientemente: se quiser deixar passar o desconhecido, use `Require expr %{ENV:GEO_COUNTRY} -in {'BR', ''}`. O nome da variável em `%{ENV:...}` é maiúsculo e o operador de pertinência do ap_expr é `-in`, com hífen; `reqenv('GEO_COUNTRY')` é equivalente e evita a confusão de caixa.

### Bloqueio no NGINX com geoip2 e map

```nginx
http {
  geoip2 /usr/share/GeoIP/GeoLite2-Country.mmdb {
    auto_reload 12h;
    $geoip2_country_iso country iso_code;
  }

  map $geoip2_country_iso $pais_bloqueado {
    default 1;
    BR      0;
    ""      0;   # sem resposta do banco: deixa passar
  }
}

server {
  location /.well-known/acme-challenge/ { allow all; }
  location /webhooks/                   { allow all; }

  location / {
    if ($pais_bloqueado) { return 403; }
    # ...
  }
}
```

### Bloqueio no LiteSpeed em cPanel pelo .htaccess

Com GeoIP ativo conforme a documentação oficial, a variável de país fica disponível para regras de reescrita no `.htaccess` do usuário, o que é útil em ambiente compartilhado porque cada conta decide a própria política sem tocar na config global:

```apache
RewriteEngine On
RewriteCond %{ENV:GEOIP_COUNTRY_CODE} !^BR$
RewriteCond %{REQUEST_URI} !^/\.well-known/acme-challenge/
RewriteCond %{REQUEST_URI} !^/webhooks/
RewriteRule ^ - [F,L]
```

## As exceções que não podem cair: ACME, webhook, buscador e monitor

Bloqueio por país quebra integração silenciosamente. O erro aparece dias depois, em forma de pedido pago que não virou pedido no sistema.

| Quem | Por que vem de fora | Como isentar |
|---|---|---||
| Googlebot, Bingbot | saída majoritariamente fora do BR | rDNS verificado, ou faixas publicadas pelos buscadores |
| ACME HTTP‑01 (Let's Encrypt) | validação multi-perspectiva, vários países | liberar `/.well-known/acme-challenge/` para todos |
| Webhooks de pagamento (Stripe, PayPal, Mercado Pago) | infra do provedor fora do BR | path dedicado liberado + validação de assinatura HMAC |
| Monitoramento externo | sondas distribuídas | allowlist por IP do fornecedor |
| CDN e WAF na frente | o IP visto é o do PoP | `mod_remoteip` / `real_ip` (próxima seção) |
| E-mail transacional com tracking pixel | aberto pelo proxy de imagem do provedor | liberar o path do pixel |

Sobre buscador: não confie em User-Agent, que é trivial de forjar. A verificação correta é rDNS em duas etapas, PTR do IP terminando em `googlebot.com` ou `google.com` e o A/AAAA desse hostname voltando ao mesmo IP.

```bash
IP=66.249.66.1
HOST=$(dig +short -x "$IP" | sed 's/\.$//')
echo "$HOST"
dig +short "$HOST"
```

Fazer rDNS em linha, por requisição, é caro e suscetível a timeout de DNS. O padrão sustentável é um job periódico que valida os IPs vistos no log, consolida uma allowlist e recarrega o servidor. As faixas publicadas em JSON pelo Google e pela Microsoft resolvem a mesma coisa sem custo em tempo de request.

Para webhook, isenção por path não é furo de segurança se o endpoint valida assinatura. Se ele não valida, o problema já existia antes do GeoIP.

## O que o GeoIP erra, e como o erro aparece no log

**CDN e proxy reverso na frente.** Com Cloudflare, proxy do provedor ou um balanceador, o IP de origem é o do PoP. Sem `mod_remoteip`/`real_ip`, o GeoIP resolve o país do data center e você bloqueia todo mundo ou ninguém. O ajuste precisa vir antes da resolução:

```nginx
set_real_ip_from 203.0.113.0/24;   # exemplo: faixa do seu proxy
real_ip_header   X-Forwarded-For;
real_ip_recursive on;
```

```apache
RemoteIPHeader X-Forwarded-For
RemoteIPTrustedProxy 203.0.113.0/24
```

Nunca confie em `X-Forwarded-For` sem lista de proxies confiáveis. O cabeçalho é texto enviado pelo cliente; sem `trusted proxy` qualquer um escreve `X-Forwarded-For: 189.0.0.1` e atravessa o bloqueio.

**VPN, Starlink e CGNAT móvel.** Cliente brasileiro em VPN corporativa sai nos Estados Unidos. Operadora móvel pode anunciar bloco registrado em outro país. Nenhum banco de geolocalização resolve isso, e o GeoLite2 é a edição gratuita, com precisão menor que a comercial. Trate o 403 como recuperável: página de erro explicando o motivo e um canal de contato valem mais que uma tela em branco.

**IPv6.** Se o site atende IPv6 e o banco só está sendo consultado no caminho IPv4, metade do tráfego escapa da regra. O GeoLite2-Country cobre as duas famílias; valide com `mmdblookup` em um IPv6 real.

**HTTP/3 e logs.** Confira que o `LogFormat` com o campo de país está aplicado em todos os vhosts e em todos os listeners, não só no default.

## Testar o bloqueio de fora e acompanhar os 403 por país

Teste de fora com um IP que você sabe estrangeiro. Sem acesso a uma máquina lá, use um resolvedor público de teste ou um nó barato em outra região.

```bash
# esperado 200
curl -s -o /dev/null -w '%{http_code}\n' https://exemplo.com.br/

# de fora do BR, esperado 404 (passou pela regra), nunca 403
# se quiser 200, crie antes: echo ok > /var/www/html/.well-known/acme-challenge/teste
curl -s -o /dev/null -w '%{http_code}\n' \
  https://exemplo.com.br/.well-known/acme-challenge/teste

# conferir que o 403 está vindo da regra, não de outra coisa
awk '$10==403 {print $2, $8}' /var/log/nginx/access.log | sort | uniq -c | sort -rn
```

Depois de ligar, acompanhe por alguns dias a contagem de 403 por país e por path. Um salto de 403 em `/checkout` ou em rota de API é sinal de falso positivo, não de ataque contido.

### Deixar a reversão a um comando de distância

Tenha o bloqueio num arquivo isolado, incluído por uma linha só. Reverter vira renomear e recarregar:

```bash
# NGINX
mv /etc/nginx/conf.d/geoblock.conf{,.off} && nginx -t && systemctl reload nginx

# Apache
a2disconf geoblock && apachectl configtest && systemctl reload apache2
```

No cPanel com `.htaccess`, mantenha as diretivas dentro de um bloco comentado e delimitado (`# BEGIN geoblock` / `# END geoblock`) para remover com um `sed` sem tocar no resto do arquivo. Guarde cópia antes.

Reload, não restart: o reload não derruba conexões em andamento e torna a reversão um evento sem downtime. Se a sua regra só pode ser desfeita com restart, ela está no lugar errado da configuração.

## Quando o bloqueio por país não é a resposta

Se o incômodo é varredura de `/wp-login.php` e `/xmlrpc.php`, limite de taxa por IP resolve sem recortar o mapa, e não quebra nada quando um cliente viaja. Se o incômodo é consumo de CPU por bot que ignora `robots.txt`, cache de página e um limite de conexões simultâneas por IP entregam mais resultado por unidade de risco. Se o incômodo é spam em formulário, validação no formulário é mais barata que GeoIP.

GeoIP brilha em dois cenários específicos: área administrativa que só deveria ser acessada do Brasil (`/wp-admin`, `/administrator`, painel interno) e aplicação com obrigação regulatória de restringir jurisdição. Restringir só o admin e deixar o site público aberto corta boa parte da tentativa de login sem risco nenhum de perder venda ou indexação. Essa é a configuração por onde eu recomendaria começar, mesmo que ela venda menos plano e resolva menos coisa do que um bloqueio total.

```apache
<LocationMatch "^/wp-(login\.php|admin/)">
  Require expr %{ENV:GEO_COUNTRY} == 'BR'
</LocationMatch>
```

Uma ressalva: `wp-admin` também é usado pelo `admin-ajax.php` em alguns temas e plugins no front-end. Rode o modo somente‑log também nesse recorte antes de fechar.

