# MySQL remoto com SSL: cifrada não quer dizer verificada

REQUIRE SSL no usuário do banco resolve metade do problema. A outra metade está no cliente, que por padrão aceita qualquer certificado sem reclamar.

> não basta aplicar REQUIRE SSL na conta do banco. O cliente MySQL 8 usa ssl-mode=PREFERRED por padrão, negocia TLS sem validar a CA e aceita certificado forjado. Só VERIFY_CA ou VERIFY_IDENTITY, com o ca.pem apontado, autenticam o servidor.

João Rizzon · 2026-10-07 · Painéis

---

Conexão remota ao MySQL funcionando não quer dizer conexão cifrada. E conexão cifrada não quer dizer conexão autenticada. São três estados diferentes, e o cliente MySQL 8 mistura os dois últimos por padrão.

O ponto cego é o `ssl-mode=PREFERRED`, default do cliente desde o MySQL 5.7/8.0: se o servidor oferece TLS, o cliente aceita; se não oferece, cai para texto claro sem avisar; e em nenhum dos casos ele valida a cadeia do certificado do servidor. A sessão fica cifrada e passa num `Ssl_cipher` não vazio, mas qualquer coisa no caminho que apresente um certificado autoassinado é aceita. Cifrado, sim. Provadamente falando com o seu servidor, não.

Este guia separa as duas pontas: o que você força do lado do servidor (na conta de usuário do banco) e o que você precisa configurar do lado do cliente para que a exigência signifique alguma coisa.

## O que cada ssl-mode do cliente faz, e onde está o salto de segurança

O parâmetro `--ssl-mode` (cliente de linha de comando, Connector/C, libmysqlclient) define dois eixos independentes: se TLS é obrigatório e se o certificado do servidor é verificado.

| ssl-mode | Cai para texto claro? | Valida assinatura pela CA? | Confere hostname no certificado? |
|---|---|---|---||
| DISABLED | sempre texto claro | não | não |
| PREFERRED (padrão) | sim, silenciosamente | não | não |
| REQUIRED | não, falha a conexão | não | não |
| VERIFY_CA | não | sim, exige `--ssl-ca` | não |
| VERIFY_IDENTITY | não | sim | sim |

O salto de segurança não está entre `PREFERRED` e `REQUIRED`. Está entre `REQUIRED` e `VERIFY_CA`. Até `REQUIRED`, um man-in-the-middle que termine o TLS com certificado próprio é aceito sem erro. A partir de `VERIFY_CA`, o cliente precisa de uma CA local para comparar. Com `VERIFY_IDENTITY`, ele ainda exige que o host que você digitou bata com o CN/SAN do certificado apresentado, o que impede reaproveitar um certificado válido emitido para outro domínio.

Se o seu sistema conecta por IP e o certificado foi emitido para `db.exemplo.com.br` (exemplo), `VERIFY_IDENTITY` vai falhar, e corretamente. Conecte pelo nome.

## O que REQUIRE SSL e REQUIRE X509 exigem da conta de usuário

A exigência mora na conta de usuário, não na instância inteira. É um atributo do par usuário@host:

```sql
-- exige apenas que a sessão esteja cifrada
ALTER USER 'usuario_app'@'203.0.113.10' REQUIRE SSL;

-- exige cifra + certificado de cliente válido assinado pela CA do servidor
ALTER USER 'usuario_app'@'203.0.113.10' REQUIRE X509;
```

`ALTER USER` já grava nas tabelas de concessão e atualiza as estruturas em memória: não precisa de `FLUSH PRIVILEGES`. O flush só é necessário se você editou `mysql.user` com `INSERT`/`UPDATE` direto, prática que não vale a pena manter.

(IP de exemplo, faixa reservada para documentação.)

Diferença prática:

- **REQUIRE SSL**: o servidor rejeita qualquer tentativa de login dessa conta em canal não cifrado. Um cliente em `PREFERRED` continua entrando, porque ele vai negociar TLS quando o servidor oferece. Você não ganha autenticação do servidor, ganha garantia de que aquela conta nunca trafega credencial em texto claro.
- **REQUIRE X509**: além da cifra, o cliente precisa apresentar um certificado de cliente assinado por uma CA que o servidor reconheça (`ssl_ca` do `my.cnf`). Isso é mútua autenticação, e muda a logística: você precisa emitir e distribuir certificado de cliente, com validade e rotação. Em hospedagem compartilhada o obstáculo é logístico: para passar no X509 você precisa de um certificado de cliente assinado pela CA configurada em `ssl_ca` do servidor, e a chave dessa CA está com quem administra a máquina. Sem o administrador emitir e devolver esse par para você, não há como atender à exigência.

Existem ainda as variantes mais restritas, `REQUIRE ISSUER '...'`, `REQUIRE SUBJECT '...'` e `REQUIRE CIPHER '...'`, que fixam emissor, sujeito e cifra. Elas são úteis em ambiente dedicado e um pesadelo de manutenção quando o certificado é renovado automaticamente, porque o sujeito pode mudar.

Verificar o que está gravado:

```sql
SELECT user, host, ssl_type, ssl_cipher, x509_issuer
  FROM mysql.user WHERE user = 'usuario_app';
```

`ssl_type` vem vazio (sem exigência), `ANY` (REQUIRE SSL), `X509` ou `SPECIFIED`.

## Como descobrir se a CA do servidor é pública ou autoassinada

Para usar `VERIFY_CA` ou `VERIFY_IDENTITY` o cliente precisa do arquivo de CA. A [documentação do cPanel sobre configuração de conexões SSL no MySQL](https://docs.cpanel.net/knowledge-base/security/how-to-configure-mysql-ssl-connections/124/) descreve o procedimento do lado do servidor, incluindo onde ficam os arquivos de chave e certificado usados pelo serviço e como apontá-los no `my.cnf`.

Na prática, para você que é o cliente, há dois caminhos:

- **O serviço usa um certificado emitido por CA pública** (AutoSSL com Let's Encrypt, por exemplo, quando o certificado do hostname é reaproveitado pelo MySQL). Nesse caso a CA já está no bundle do sistema operacional e você não precisa de arquivo nenhum: basta usar `VERIFY_IDENTITY` conectando pelo hostname certo. Em muitas distros o bundle está em `/etc/ssl/certs/ca-certificates.crt` (Debian/Ubuntu) ou `/etc/pki/tls/certs/ca-bundle.crt` (RHEL/Alma/Rocky).
- **O serviço usa CA própria/autoassinada** (cenário comum quando o MySQL ficou com os arquivos gerados na instalação). Aí você precisa do `ca.pem` correspondente, fornecido por quem administra o servidor. Sem ele, `VERIFY_CA` não tem como funcionar, e insistir em `REQUIRED` é se contentar com cifra sem identidade.

Para descobrir em qual cenário você está, antes de escrever código:

```bash
openssl s_client -connect db.exemplo.com.br:3306 \
  -starttls mysql -showcerts </dev/null 2>/dev/null \
  | openssl x509 -noout -subject -issuer -dates
```

`-starttls mysql` existe no OpenSSL 1.1.1 em diante e faz o handshake no protocolo do MySQL antes de subir o TLS. Se `issuer` for uma CA pública, caminho 1. Se `subject` e `issuer` forem iguais, é autoassinado, caminho 2.

## Configurar o cliente para verificar, não apenas cifrar

### Linha de comando, com o teste de controle negativo

```bash
mysql -h db.exemplo.com.br -u usuario_app -p \
  --ssl-mode=VERIFY_IDENTITY \
  --ssl-ca=/etc/ssl/certs/ca-certificates.crt
```

Teste de controle que vale mais que o teste positivo: rode a mesma linha com `--ssl-mode=DISABLED`. Se a conta tem `REQUIRE SSL`, o login tem que falhar. Se entrar, a exigência não foi aplicada na combinação usuário@host que você está usando (lembre que `'app'@'%'` e `'app'@'203.0.113.10'` são contas distintas, com atributos distintos).

### PHP com PDO e as duas constantes que precisam andar juntas

```php
$dsn = 'mysql:host=db.exemplo.com.br;dbname=app;charset=utf8mb4';
$opt = [
    PDO::MYSQL_ATTR_SSL_CA => '/etc/ssl/certs/ca-certificates.crt',
    PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT => true,
    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
];
$pdo = new PDO($dsn, 'usuario_app', $senha, $opt);
```

Dois detalhes que derrubam muita gente:

- `MYSQL_ATTR_SSL_VERIFY_SERVER_CERT` só existe a partir do PHP 7.1 e, com `mysqlnd`, definir `MYSQL_ATTR_SSL_CA` sozinho não garante verificação. Defina os dois.
- Com `mysqlnd`, `VERIFY_SERVER_CERT => true` valida a cadeia contra a CA informada, o que equivale a `VERIFY_CA`. A conferência do hostname contra CN/SAN depende da versão do PHP e do driver (com libmysqlclient o comportamento também difere), então não assuma `VERIFY_IDENTITY`. Para checar na prática: aponte o DSN para o IP do servidor em vez do nome. Se a conexão abrir normalmente, o hostname não está sendo conferido.
- Em versões antigas havia quem passasse `false` nessa constante para "fazer funcionar". Isso rebaixa a conexão para o equivalente a `REQUIRED`. Se você precisou disso, o problema é o certificado ou o hostname, não a flag.

### MySQL Workbench e o que preencher na aba SSL

Na conexão, aba **SSL**: escolha `Require and Verify CA` ou `Require and Verify Identity`, e aponte **SSL CA File** para o `ca.pem` ou para o bundle do sistema. Os campos SSL Cert e SSL Key só são necessários se a conta estiver com `REQUIRE X509`.

## Provar pela sessão aberta que o canal está cifrado

Não confie na configuração, confie na sessão aberta. Três checagens, da mais rápida para a mais completa.

```sql
-- 1) resumo do cliente (apenas no cliente oficial):
\s
-- a linha "SSL:" mostra a cifra em uso ou "Not in use"

-- 2) variável de status da sessão:
SHOW SESSION STATUS LIKE 'Ssl_cipher';
SHOW SESSION STATUS LIKE 'Ssl_version';

-- 3) visão do servidor sobre a conexão atual (MySQL 8.0.16+, com performance_schema=ON):
SELECT * FROM performance_schema.status_by_thread
 WHERE thread_id = PS_CURRENT_THREAD_ID()
   AND variable_name IN ('Ssl_cipher','Ssl_version');

-- 3b) fallback para 5.7 e 8.0 anteriores a 8.0.16:
SELECT s.variable_name, s.variable_value
  FROM performance_schema.status_by_thread s
  JOIN performance_schema.threads t ON t.thread_id = s.thread_id
 WHERE t.processlist_id = CONNECTION_ID()
   AND s.variable_name IN ('Ssl_cipher','Ssl_version');
```

`Ssl_cipher` vazio significa texto claro, ponto final. Com valor, a sessão está cifrada e `Ssl_version` diz se você está em TLSv1.2 ou TLSv1.3.

O que nenhuma dessas consultas responde: se o certificado foi verificado. Isso acontece no cliente, durante o handshake, e o servidor não registra o modo escolhido pelo cliente. A prova de verificação é do outro lado: `--ssl-mode=VERIFY_IDENTITY` conectar sem erro apontando a CA correta. O comando `openssl s_client` da seção anterior descarta stderr e canaliza a saída para `openssl x509`, então ele mostra quem emitiu o certificado, não se ele valida. Para ver o veredito da validação, rode sem pipe e com a CA explícita:

```bash
openssl s_client -connect db.exemplo.com.br:3306 \
  -starttls mysql -CAfile /etc/ssl/certs/ca-certificates.crt \
  -verify_hostname db.exemplo.com.br </dev/null 2>&1 | grep -E 'Verify return code|verify error'
```

A linha esperada é `Verify return code: 0 (ok)`. `-verify_hostname` existe desde o OpenSSL 1.0.2; já o `-starttls mysql` só a partir do 1.1.1.

## Erros de TLS no MySQL e o que cada mensagem significa

| Mensagem | Causa provável | Onde corrigir |
|---|---|---||
| `Access denied ... (using password: YES)` logo após ativar REQUIRE SSL | cliente em DISABLED, ou conta duplicada em outro host | cliente: `--ssl-mode=REQUIRED` |
| `SSL connection error: ... certificate verify failed` | CA errada ou cadeia incompleta | apontar o `ca.pem` correto |
| `SSL certificate validation failure` com hostname | conectou por IP com VERIFY_IDENTITY | conectar pelo nome do certificado |
| `TLS version ... not supported` | cliente antigo contra servidor que removeu TLS 1.0/1.1 | atualizar o conector |
| Conexão abre, mas `Ssl_cipher` vazio | servidor sem TLS habilitado; cliente em PREFERRED não reclamou | servidor |

A última linha é o resumo do artigo inteiro: em `PREFERRED`, a falha é silenciosa. Em qualquer ambiente que você precise auditar, nunca deixe o default.

## Ordem de implantação que não derruba produção

Ativar `REQUIRE SSL` antes de o cliente estar pronto derruba a aplicação na hora. A sequência segura:

- Confirme que o servidor oferece TLS (`openssl s_client -starttls mysql`) e anote emissor e hostname do certificado.
- Ajuste o cliente para `VERIFY_CA` ou `VERIFY_IDENTITY` e suba em produção. Com a conta ainda sem exigência, se der errado você volta sem downtime do banco.
- Valide com `SHOW SESSION STATUS LIKE 'Ssl_cipher'` em uma sessão real da aplicação, não no seu terminal.
- Só então aplique `ALTER USER ... REQUIRE SSL`.
- Teste o controle negativo com `--ssl-mode=DISABLED` e confirme a rejeição.

Reversão, se precisar: `ALTER USER 'usuario_app'@'host' REQUIRE NONE;`. A conta volta a aceitar texto claro imediatamente, sem flush e sem reiniciar o serviço (sessões já abertas continuam como estão até reconectarem).

E o conselho que contraria o roteiro comercial: se o seu banco e a sua aplicação estão no mesmo servidor, conectando por `localhost` via socket Unix, TLS no MySQL não acrescenta nada e só adiciona handshake por conexão. O cenário que justifica tudo acima é aplicação em uma máquina e banco em outra, atravessando rede pública. Para esse caso, cifra sem verificação de CA cumpre um checklist, não um modelo de ameaça.

