# TXT com mais de 255 caracteres: como salvar a chave DKIM

O limite vale para cada trecho entre aspas, não para o registro. Como quebrar a chave dentro de um único TXT, por que o SPF não pode virar dois registros e como conferir o resultado em consulta pública.

> o limite de 255 caracteres vale para cada trecho entre aspas dentro do TXT, não para o registro inteiro. Quebre a chave DKIM em trechos de até 255 no mesmo registro e confirme com dig que ela volta concatenada.

João Rizzon · 2026-11-16 · Domínios e DNS

---

## Por que cada trecho entre aspas não pode passar de 255 caracteres

O registro TXT do DNS não guarda um texto único. Ele guarda uma sequência de **character-strings**, e o formato do protocolo DNS reserva um único byte para o tamanho de cada uma. Um byte vai até 255. Por isso cada trecho tem no máximo 255 caracteres, e o registro inteiro pode ter vários trechos.

Na prática isso quer dizer duas coisas:

- Uma chave DKIM de 2048 bits passa de 255 caracteres com folga e **não cabe em um trecho só**.
- Ela cabe perfeitamente em **um registro só**, desde que dividida em dois ou mais trechos entre aspas.

Quando o painel recusa o valor ou a validação do provedor de e-mail falha, quase sempre o problema é este: o valor foi colado como um bloco único entre aspas, ou foi espalhado em registros separados. O DNS aceita a chave longa. O que ele não aceita é um trecho longo.

Quem consulta o registro (o servidor que verifica a assinatura DKIM) junta os trechos na ordem em que aparecem, **sem inserir espaço entre eles**. Essa regra de concatenação é o que permite quebrar a chave em qualquer ponto.

## Como quebrar a chave DKIM dentro de um único registro

O procedimento é o mesmo em qualquer editor de zona que aceite valor TXT com aspas. A documentação do cPanel descreve a criação e edição de registros TXT na interface **Zone Editor** ([docs.cpanel.net](https://docs.cpanel.net/cpanel/domains/zone-editor/130/)). Alguns painéis dividem o valor longo sozinhos ao salvar, outros recusam. Não presuma o comportamento: confira depois com a consulta pública descrita mais abaixo.

### Como copiar a chave sem herdar quebras de um valor antigo

Pegue o valor exatamente como o provedor de e-mail entregou, começando em `v=DKIM1`. Se o provedor já entregou o valor quebrado com aspas, junte tudo primeiro: remova as aspas e os espaços entre os trechos para ter uma linha contínua. Isso evita herdar uma quebra malfeita.

### Como dividir a chave em trechos de até 255 caracteres

Você pode cortar em qualquer posição, inclusive no meio da chave base64, porque a concatenação não adiciona nada. Uma margem abaixo de 255 evita erro de contagem. No terminal, com o valor salvo em um arquivo:

```
fold -w 250 chave.txt
```

O `fold` imprime o conteúdo em linhas de até 250 caracteres. Cada linha vira um trecho.

### Como montar o valor com os trechos entre aspas

Coloque cada trecho entre aspas duplas, separados por um espaço, no campo de valor de **um único** registro TXT. Exemplo fictício, com a chave encurtada para caber aqui:

```
"v=DKIM1; k=rsa; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA..." "...restante da chave IDAQAB"
```

O nome do registro continua o que o provedor indicou, no formato `seletor._domainkey`. A configuração completa do DKIM por provedor está nos nossos guias de SPF e DKIM e no de verificação do Microsoft 365. Aqui o foco é só fazer o valor longo entrar.

## Por que o SPF não pode virar dois registros TXT

A tentação, quando o SPF fica grande, é criar um segundo TXT com o resto dos mecanismos. Isso quebra o SPF. O protocolo SPF exige que o domínio tenha **um único** registro começando em `v=spf1`. Se o verificador encontra dois, o resultado é erro permanente (`permerror`), e o efeito prático é o mesmo de não ter SPF, ou pior, dependendo da política do destino.

O segundo registro também não seria lido como continuação do primeiro. Registros TXT diferentes são independentes. Só os trechos dentro do mesmo registro são concatenados.

Se o SPF passou de 255 caracteres, a saída é a mesma do DKIM: um registro, vários trechos entre aspas. Atenção ao ponto de corte: como a junção não insere espaço, deixe o espaço que separa os mecanismos dentro de um dos trechos. Exemplo fictício:

```
"v=spf1 include:_spf.exemplo-provedor.com include:mail.exemplo-crm.com " "ip4:203.0.113.10 ~all"
```

Repare no espaço antes da aspa que fecha o primeiro trecho. Sem ele, os dois mecanismos grudam e o registro fica inválido. Se o SPF está crescendo por acúmulo de `include`, vale revisar se todos os serviços ainda enviam em nome do domínio antes de só dividir o texto.

## Como confirmar por consulta pública que a chave voltou inteira

O painel mostrar o registro salvo não prova nada. O que importa é o que um resolvedor externo devolve. Use um resolvedor público para não ler cache local:

```
dig +short TXT seletor._domainkey.exemplo.com.br @8.8.8.8
```

No Windows:

```
nslookup -type=TXT seletor._domainkey.exemplo.com.br 8.8.8.8
```

O que observar na resposta:

- **Uma linha só** na saída do `dig +short`, com dois ou mais trechos entre aspas. Duas linhas separadas significam dois registros TXT no mesmo nome, e isso é erro.
- No `nslookup` a contagem é diferente: os trechos de um mesmo registro aparecem em linhas sucessivas, todos sob uma única entrada `text =`. Várias linhas ali são normais. Dois registros aparecem como duas entradas `text =` separadas, e só isso é erro.
- O início do primeiro trecho é `v=DKIM1` e o fim do último bate com o fim da chave que o provedor entregou.
- Nenhum espaço, quebra de linha ou aspa extra dentro da chave base64.

Para o SPF, consulte o domínio raiz e conte quantas respostas começam com `v=spf1` (no `dig +short`, uma por linha; no `nslookup`, uma por entrada `text =`). Tem que ser exatamente uma.

Se a resposta vier vazia ou antiga, considere o TTL do registro anterior antes de concluir que deu errado. Depois que o DNS responder certo, rode a validação no painel do provedor de e-mail.

## Erros que fazem o painel recusar ou corromper o registro

| Sintoma | Causa provável | Correção |
|---|---|---||
| Painel recusa o valor ao salvar | Um único trecho com mais de 255 caracteres | Dividir em trechos entre aspas no mesmo registro |
| `dig` devolve duas linhas para o mesmo nome | Chave ou SPF espalhado em dois registros TXT | Apagar ambos e criar um registro com vários trechos |
| Validação DKIM falha com o registro presente | Espaço ou quebra de linha colado no meio da chave | Reconstruir a linha contínua e dividir de novo |
| SPF com `permerror` | Dois registros `v=spf1` ou mecanismos grudados no corte | Um registro só, com o espaço mantido dentro de um trecho |
| Aspas aparecendo dentro do valor na consulta | Aspas escapadas ou duplicadas pelo painel | Remover aspas extras e salvar de novo |
| Registro aparece no painel, mas não na consulta | Zona editada não é a autoritativa do domínio | Conferir os nameservers do domínio antes de editar |

O último caso é comum em domínio que trocou de hospedagem: a zona antiga continua editável no painel, mas o DNS público responde de outro lugar.

## Checklist para padronizar nos sites dos clientes

Use a mesma sequência em todo cliente, e guarde o valor original da chave junto da documentação do projeto:

- Confirmar quais nameservers respondem pelo domínio antes de editar qualquer zona.
- Guardar o valor da chave DKIM em linha contínua, sem aspas.
- Dividir com `fold -w 250` e montar os trechos entre aspas.
- Criar **um** registro TXT no nome `seletor._domainkey`.
- Verificar que existe um único `v=spf1` no domínio raiz; se for dividir, manter o espaço no ponto de corte.
- Consultar com `dig` em resolvedor público e conferir início, fim e número de linhas.
- Só então validar no provedor de e-mail.

Para explicar ao cliente que pergunta por que o e-mail ainda não está autenticado, uma frase que funciona: **"A chave de segurança do e-mail é maior do que o DNS aceita em um bloco só, então ela precisa ser gravada em partes dentro do mesmo registro. Já gravei e conferi de fora que o servidor está entregando a chave completa."**

Nada disso exige trocar de painel ou de plano. Se o editor de zona do seu cliente aceita aspas no campo de valor, ele costuma aceitar as chaves de 1024 e 2048 bits usuais. Ainda assim, alguns painéis recusam ou alteram o valor ao salvar, então só considere o trabalho feito depois de confirmar com `dig` que a chave voltou inteira.

