# Usar o SSL com uma instância de banco de dados PostgreSQL
O Amazon RDS oferece suporte à criptografia de Secure Socket Layer (SSL) para instâncias de banco de dados PostgreSQL. Por meio do SSL, você pode criptografar uma conexão do PostgreSQL entre seus aplicativos e suas instâncias de banco de dados PostgreSQL. Por padrão, o RDS para PostgreSQL usa e espera que todos os clientes se conectem usando SSL/TLS, mas você também pode exigir isso. O RDS para PostgreSQL é compatível com o Transport Layer Security (TLS) versões 1.1, 1.2 e 1.3.
Para obter informações gerais sobre o suporte para SSL e bancos de dados PostgreSQL, consulte [Suporte para SSL](https://www.postgresql.org/docs/11/libpq-ssl.html) na documentação do PostgreSQL. Para obter informações sobre como usar uma conexão SSL via JDBC, consulte [Configurar o cliente](https://jdbc.postgresql.org/documentation/head/ssl-client.html) na documentação do PostgreSQL.
O suporte a SSL está disponível em todas as regiões da AWS para o PostgreSQL. O Amazon RDS cria um certificado SSL para sua instância de banco de dados do PostgreSQL quando essa instância é criada. Se você habilitar a verificação de certificado SSL, o certificado SSL incluirá o endpoint da instância de banco de dados como o nome comum (CN) do certificado SSL para se proteger contra ataques de falsificação.
**Topics**
+ [Conectar-se à instância de banco de dados PostgreSQL via SSL](#PostgreSQL.Concepts.General.SSL.Connecting)
+ [Exigir uma conexão SSL para uma instância de banco de dados PostgreSQL](#PostgreSQL.Concepts.General.SSL.Requiring)
+ [Determinar o status de conexão SSL](#PostgreSQL.Concepts.General.SSL.Status)
+ [Suítes de cifras SSL no RDS para PostgreSQL](#PostgreSQL.Concepts.General.SSL.Ciphers)
## Conectar-se à instância de banco de dados PostgreSQL via SSL
**Para se conectar à instância de banco de dados PostgreSQL via SSL**
1. Baixe o certificado.
Para obter informações sobre como baixar certificados, consulte [Usar SSL/TLS para criptografar uma conexão com uma instância ou um cluster de banco de dados](UsingWithRDS.SSL.md).
1. Conecte-se à sua instância de banco de dados PostgreSQL via SSL.
Quando você se conecta usando SSL, seu cliente pode escolher se deseja verificar a cadeia de certificados. Se os seus parâmetros de conexão especificarem `sslmode=verify-ca` ou `sslmode=verify-full`, seu cliente exigirá que os certificados de CA do RDS estejam no armazenamento confiável ou sejam referenciados no URL da conexão. Esse requisito tem o objetivo de verificar a cadeia de certificados que assina o seu certificado de banco de dados.
Quando um cliente, como psql ou JDBC, é configurado com suporte para SSL, primeiro ele tenta se conectar ao banco de dados via SSL por padrão. Se esse cliente não puder se conectar via SSL, ele voltará a se conectar sem SSL. O modo `sslmode` padrão utilizado é diferente entre os clientes baseados em libpq (como o psql) e o JDBC. Os clientes JDBC e baseados em libpq usam `prefer` como padrão.
Use o parâmetro `sslrootcert` para fazer referência ao certificado, por exemplo `sslrootcert=rds-ssl-ca-cert.pem`.
Veja a seguir um exemplo de uso do `psql` para se conectar a uma instância de banco de dados do PostgreSQL usando SSL com verificação de certificado.
```
$ psql "host=db-name.555555555555.ap-southeast-1.rds.amazonaws.com
port=5432 dbname=testDB user=testuser sslrootcert=rds-ca-rsa2048-g1.pem sslmode=verify-full"
```
## Exigir uma conexão SSL para uma instância de banco de dados PostgreSQL
Você pode exigir que conexões estabelecidas a sua instância de banco de dados PostgreSQL usem SSL por meio do parâmetro `rds.force_ssl`. O valor padrão do parâmetro `rds.force_ssl` é 1 (ativado) para o RDS para PostgreSQL versão 15 e posterior. Para todas as outras versões principais do RDS para PostgreSQL 14 e posterior, o valor padrão desse parâmetro é 0 (desativado). Você pode definir o parâmetro `rds.force_ssl` como 1 (ativado) para exigir SSL/TLS para conexões com o seu cluster de banco de dados. Você pode definir o parâmetro `rds.force_ssl` como 1 (ativado) para exigir o SSL para conexões a sua instância de banco de dados.
Para alterar o valor desse parâmetro, você precisa criar um grupo de parâmetros de banco de dados personalizado. Depois precisará alterar o valor de `rds.force_ssl` em seu grupo de parâmetros de banco de dados personalizado para `1` para ativar esse recurso. Se você preparar o grupo de parâmetros de banco de dados personalizado antes de criar sua instância de banco de dados do RDS para PostgreSQL, poderá escolhê-lo (em vez de um grupo de parâmetros padrão) durante o processo de criação. Se você fizer isso depois que a instância de banco de dados do RDS para PostgreSQL já estiver em execução, será necessário reinicializar a instância para que ela use o grupo de parâmetros personalizado. Para obter mais informações, consulte [Grupos de parâmetros para Amazon RDS](USER_WorkingWithParamGroups.md).
Quando o recurso `rds.force_ssl` está ativo em sua instância de banco de dados, as tentativas de conexão que não estão usando SSL são rejeitadas com a seguinte mensagem:
```
$ psql -h db-name.555555555555.ap-southeast-1.rds.amazonaws.com port=5432 dbname=testDB user=testuser
psql: error: FATAL: no pg_hba.conf entry for host "w.x.y.z", user "testuser", database "testDB", SSL off
```
## Determinar o status de conexão SSL
O status criptografado da conexão é mostrado no banner de login ao se conectar à instância de banco de dados:
```
Password for user master:
psql (10.3)
SSL connection (cipher: DHE-RSA-AES256-SHA, bits: 256)
Type "help" for help.
postgres=>
```
Você também pode carregar a extensão `sslinfo` e chamar a função `ssl_is_used()` para determinar se o SSL está sendo usado. A função retornará `t` se a conexão estiver usando o SSL, caso contrário, retornará `f`.
```
postgres=> CREATE EXTENSION sslinfo;
CREATE EXTENSION
postgres=> SELECT ssl_is_used();
ssl_is_used
---------
t
(1 row)
```
Para obter informações mais detalhadas, use a seguinte consulta para obter informações de `pg_settings`:
```
SELECT name as "Parameter name", setting as value, short_desc FROM pg_settings WHERE name LIKE '%ssl%';
Parameter name | value | short_desc
----------------------------------------+-----------------------------------------+-------------------------------------------------------
ssl | on | Enables SSL connections.
ssl_ca_file | /rdsdbdata/rds-metadata/ca-cert.pem | Location of the SSL certificate authority file.
ssl_cert_file | /rdsdbdata/rds-metadata/server-cert.pem | Location of the SSL server certificate file.
ssl_ciphers | HIGH:!aNULL:!3DES | Sets the list of allowed SSL ciphers.
ssl_crl_file | | Location of the SSL certificate revocation list file.
ssl_dh_params_file | | Location of the SSL DH parameters file.
ssl_ecdh_curve | prime256v1 | Sets the curve to use for ECDH.
ssl_key_file | /rdsdbdata/rds-metadata/server-key.pem | Location of the SSL server private key file.
ssl_library | OpenSSL | Name of the SSL library.
ssl_max_protocol_version | | Sets the maximum SSL/TLS protocol version to use.
ssl_min_protocol_version | TLSv1.2 | Sets the minimum SSL/TLS protocol version to use.
ssl_passphrase_command | | Command to obtain passphrases for SSL.
ssl_passphrase_command_supports_reload | off | Also use ssl_passphrase_command during server reload.
ssl_prefer_server_ciphers | on | Give priority to server ciphersuite order.
(14 rows)
```
Você também pode coletar todas as informações sobre o uso de SSL da instância de banco de dados do RDS para PostgreSQL por processo, cliente e aplicação usando a seguinte consulta:
```
SELECT datname as "Database name", usename as "User name", ssl, client_addr, application_name, backend_type
FROM pg_stat_ssl
JOIN pg_stat_activity
ON pg_stat_ssl.pid = pg_stat_activity.pid
ORDER BY ssl;
Database name | User name | ssl | client_addr | application_name | backend_type
---------------+-----------+-----+----------------+------------------------+------------------------------
| | f | | | autovacuum launcher
| rdsadmin | f | | | logical replication launcher
| | f | | | background writer
| | f | | | checkpointer
| | f | | | walwriter
rdsadmin | rdsadmin | t | 127.0.0.1 | | client backend
rdsadmin | rdsadmin | t | 127.0.0.1 | PostgreSQL JDBC Driver | client backend
postgres | postgres | t | 204.246.162.36 | psql | client backend
(8 rows)
```
Para identificar a criptografia usada para sua conexão SSL, você pode consultar da seguinte forma:
```
postgres=> SELECT ssl_cipher();
ssl_cipher
--------------------
DHE-RSA-AES256-SHA
(1 row)
```
Para saber mais sobre a opção `sslmode`, consulte [Funções de controle de conexão com o banco de dados](https://www.postgresql.org/docs/11/libpq-connect.html#LIBPQ-CONNECT-SSLMODE) na *documentação do PostgreSQL*.
## Suítes de cifras SSL no RDS para PostgreSQL
O parâmetro de configuração do PostgreSQL, [ssl\$1ciphers](https://www.postgresql.org/docs/current/runtime-config-connection.html#RUNTIME-CONFIG-CONNECTION-SSL), especifica as categorias de suítes de cifras permitidas para conexões SSL com o banco de dados ao usar o TLS 1.2 e anterior.
No RDS para PostgreSQL 16 e versões posteriores, você pode modificar o parâmetro `ssl_ciphers` para usar valores específicos das suítes de cifras permitidas. Esse é um parâmetro dinâmico que não exige a reinicialização da instância do banco de dados. Para visualizar as suítes de cifras permitidas, use o console do Amazon RDS ou o seguinte comando da AWS CLI:
```
aws rds describe-db-parameters --db-parameter-group-name --region --endpoint-url --output json | jq '.Parameters[] | select(.ParameterName == "ssl_ciphers")'
```
A tabela a seguir lista as suítes de cifras padrão e as suítes de cifras permitidas para versões que aceitam configurações personalizadas.
| Versão do mecanismo PostgreSQL | Valores padrão da suíte de ssl\$1ciphers | Valores personalizados permitidos da suíte de ssl\$1ciphers |
| --- | --- | --- |
| 18 | HIGH:\$1aNULL:\$13DES | `TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384` `TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256` `TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256` `TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384` `TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256` |
| 17 | HIGH:\$1aNULL:\$13DES | `TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384` `TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256` `TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256` `TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384` `TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256` |
| 16 | HIGH:\$1aNULL:\$13DES | `TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384` `TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256` `TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256` `TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384` `TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256` |
| 15 | HIGH:\$1aNULL:\$13DES | Não é possível usar ssl\$1ciphers personalizados |
| 14 | HIGH:\$1aNULL:\$13DES | Não é possível usar ssl\$1ciphers personalizados |
| 13 | HIGH:\$1aNULL:\$13DES | Não é possível usar ssl\$1ciphers personalizados |
| 12 | HIGH:\$1aNULL:\$13DES | Não é possível usar ssl\$1ciphers personalizados |
| 11.4 e versões secundárias posteriores | HIGH:MEDIUM:\$13DES:\$1aNULL:\$1RC4 | Não é possível usar ssl\$1ciphers personalizados |
| 11.1, 11.2 | HIGH:MEDIUM:\$13DES:\$1aNULL | Não é possível usar ssl\$1ciphers personalizados |
| 10.9 e versões secundárias posteriores | HIGH:MEDIUM:\$13DES:\$1aNULL:\$1RC4 | Não é possível usar ssl\$1ciphers personalizados |
| 10.7 e versões secundárias anteriores | HIGH:MEDIUM:\$13DES:\$1aNULL | Não é possível usar ssl\$1ciphers personalizados |
Para configurar todas as conexões de instância e usar a suíte de cifras `TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384`, modifique seu grupo de parâmetros conforme mostrado no seguinte exemplo:
```
aws rds modify-db-parameter-group --db-parameter-group-name --parameters "ParameterName='ssl_ciphers',ParameterValue='TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384',ApplyMethod=immediate"
```
Este exemplo usa uma cifra ECDSA, que exige que sua instância use uma autoridade de certificação com criptografia de curva elíptica (ECC) para estabelecer uma conexão. Para obter informações sobre as autoridades de certificação oferecidas pelo Amazon RDS, consulte [Certificate authorities](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/singWithRDS.SSL.html#UsingWithRDS.SSL.RegionCertificateAuthorities).
Você pode verificar as cifras em uso por meio dos métodos descritos em [Determinar o status de conexão SSL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Concepts.General.SSL.html#PostgreSQL.Concepts.General.SSL.Status).
As cifras podem ter nomes diferentes dependendo do contexto:
+ As cifras da lista de permissões que você pode configurar em seu grupo de parâmetros são referidas com o respectivo nome da Internet Assigned Numbers Authority (IANA).
+ Os banners de logon `sslinfo` e `psql` se referem às cifras usando o respectivo nome do OpenSSL.
Por padrão, o valor de `ssl_max_protocol_version` no RDS para PostgreSQL 16 e versões posteriores é TLS v1.3. Você deve definir o valor desse parâmetro como TLS v1.2, pois o TLS v1.3 não usa as configurações de cifra especificadas no parâmetro `ssl_ciphers`. Quando você define o valor como TLS v1.2, as conexões usam somente as cifras que você define em `ssl_ciphers`.
```
aws rds modify-db-parameter-group --db-parameter-group-name --parameters "ParameterName='ssl_max_protocol_version',ParameterValue='TLSv1.2',ApplyMethod=immediate"
```
Para garantir que as conexões do banco de dados usem SSL, defina `rds.force_ssl parameter` como 1 no seu grupo de parâmetros. Para obter mais informações sobre parâmetros e grupos de parâmetros, consulte [Grupos de parâmetros para Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html).