Definindo TLS/SSL com Outras Ferramentas

Destaca fluxos de trabalho de ferramentas de chave GnuTLS, NSS e Java para criar e gerenciar certificados no Oracle Linux.

Examinar ferramentas adicionais que você pode considerar para definir TLS/SSL.

Vários fatores podem influenciar na escolha da ferramenta. Por exemplo, algumas ferramentas são mais leves do que outras, ou algumas são direcionadas a ambientes específicos, como a ferramenta de teclas para Java. Algumas abrangem não apenas o gerenciamento da infraestrutura de certificados, mas também outros recursos, APIs e bibliotecas para o desenvolvimento de aplicativos que permitem vários outros protocolos de rede seguros e padrões de segurança. Embora este manual não forneça detalhes sobre tais recursos, você pode encontrar mais informações sobre eles nas páginas manuais correspondentes e na documentação de projetos de código-fonte aberto.

NúTLS

Mostra como usar a ferramenta cert para gerar chaves, CSRs e certificados autoassinados.

A ferramenta de certificado certtool GnuTLS disponível no Oracle Linux cria solicitações de assinatura de certificado, certificados autoassinados e certificados de CA de propriedade privada. O GnuTLS é uma biblioteca que fornece implementações dos protocolos SSL, TLS e DTLS, junto com tecnologias relacionadas, para proteger comunicações. Inclui uma API (Application Programming Interface) escrita em linguagem C para acessar os protocolos de comunicação seguros e APIs para analisar e escrever estruturas como X.509, PKCS #12 e OpenPGP.

Para usar o certtool, instale o pacote gnutls-utils, disponível no repositório do Application Stream:

sudo dnf install gnutls-utils

Os exemplos a seguir mostram como usar o comando certtool para criar solicitações de assinatura de certificado, certificados autoassinados e certificados de CA de propriedade privada.

Para gerar uma chave privada, execute o seguinte comando, substituindo private_key_file pelo nome do arquivo de chave privada:
```
sudo certtool --generate-privkey --outfile private_key_file
```
Para gerar um CSR, execute o seguinte comando, substituindo csr_file pelo nome do arquivo CSR:
```
sudo certtool --generate-request --load-privkey private_key_file --outfile csr_file
```

Para gerar um certificado autoassinado, execute o seguinte comando:

sudo certtool --generate-self-signed --load-privkey private_key_file --outfile self_signed_certificate_file

Para obter mais informações, consulte a página do manual certtool(1) e o projeto de código aberto GnuTLS em https://www.gnutls.org/.

NSS

Descreve o gerenciamento de certificados e chaves com os comandos certutil e pk12util do NSS.

A ferramenta de certificado do NSS (Network Security Service) certutil disponível no Oracle Linux e como usá-la para criar Solicitações de Assinatura de Certificado (CSRs), certificados autoassinados e certificados de CA de propriedade privada com arquivos de banco de dados do NSS que armazenam certificados e chaves privadas para aplicativos.

NSS é um conjunto de bibliotecas projetadas para permitir o desenvolvimento entre plataformas de aplicativos cliente e servidor habilitados para segurança. Aplicações criadas com NSS funcionam com certificados SSL v2 e v3, TLS, PKCS #5, PKCS #7, PKCS #11, PKCS #12, S/MIME, X.509 v3 e outros padrões de segurança.

Para poder usar o certutil para gerenciar certificados, CSRs e chaves, você deve ter acesso aos arquivos do banco de dados NSS. Você pode usar os arquivos de bancos de dados de segurança legados (cert8.db para certificados, key3.db para chaves e secmod.db para informações de módulo PKCS #11) ou os novos arquivos de banco de dados SQLite (cert9.db para certificados, key4.db para chaves e pkcs11.txt para módulos PKCS #11). Esta seção fornece exemplos dos novos arquivos de banco de dados.

Você também pode usar o comando pk12util relacionado para exportar e importar certificados e chaves de um arquivo PKCS #12 para um banco de dados NSS ou o inverso.

Para usar certutil e pk12util, instale o pacote nss-tools disponível no repositório do Application Stream:

sudo dnf install nss-tools

Os exemplos a seguir mostram como usar os comandos certutil e pk12util.

Para criar um banco de dados NSS, execute o seguinte comando, em que database_directory é o diretório home no qual você deseja criar os arquivos de banco de dados NSS cert9.db, key4.db e pkcs11.txt:
```
certutil -N -d database_directory
```
Por exemplo, o seguinte cria o banco de dados em uma pasta chamada nssdb no diretório home do usuário:
```
certutil -N -d $HOME/nssdb
```
Para gerar um certificado autoassinado, execute o seguinte comando:
```
certutil -d database_directory -S -s subject -n nickname -x -t trust_args -o file
```
Neste exemplo:
- -S Indica que você deseja criar um certificado individual e adicioná-lo a um banco de dados de certificados.
- -s Indica que você deseja especificar um nome distinto em que sujeito usa o formato de nome distinto definido em https://www.rfc-editor.org/rfc/rfc1485.html.
- -n Indica que você deseja especificar um apelido em que nickname é o apelido da entidade que você está criando.
- -x Indica que você deseja gerar a assinatura de um certificado que está sendo criado ou adicionado a um banco de dados, em vez de obter uma assinatura de uma CA separada.
- -t Indica que você deseja adicionar argumentos de confiança em que trust_args são os atributos de confiança que você deseja aplicar ao certificado. Cada certificado tem três categorias de confiança, expressas na ordem SSL, email, assinatura de objeto para cada configuração de confiança. Em cada posição de categoria, use nenhum, nenhum ou todos os códigos de atributo. Os códigos válidos são:
  - p - Par válido
  - P - Par confiável (inclui p)
  - c - CA Válida
  - C - CA Confiável (inclui c)
  - T - CA confiável para autenticação de cliente (somente servidor SSL)
Por exemplo, o comando a seguir cria um certificado autoassinado para o nome comum www1.example.com com o apelido example_test. Os atributos de confiança são C (CA Confiável) para cada categoria.
```
certutil -d $HOME/nssdb/ -S -s 'CN=www1.example.com, O=Example Organization, L=Ottawa, C=CA' -n example_test -x -t C,C,C
```
Para adicionar certificados ou certificados existentes gerados em outro lugar, execute o seguinte comando:
```
certutil -A -n nickname -t trust_args -d database_directory -i input-file
```
Onde:
- -A Indica que você deseja adicionar um certificado a um banco de dados de certificados.
- -i Indica que você deseja fornecer um arquivo de entrada, como um arquivo de certificado, por exemplo, um arquivo PEM.
Por exemplo:
```
certutil -A -n "CN=My SSL Certificate" -t C,C,C -d $HOME/nssdb/ -i $HOME/tls-ca-bundle.pem
```

Para listar todos os certificados, execute o seguinte comando:

certutil -L -d database_directory

Por exemplo:

certutil -L -d $HOME/nssdb/

Certificate Nickname                                         Trust Attributes
                                                             SSL,S/MIME,JAR/XPI

example_test                                                 Cu,Cu,Cu
CN=My SSL Certificate                                        C,C,C

Ao listar certificados, as tags de confiança podem incluir o flag u indicando que uma chave privada está associada ao certificado.

Para excluir um certificado do banco de dados, execute o seguinte comando:
```
certutil -D -d database_directory -n nickname
```
No exemplo anterior, -D indica que você deseja excluir um certificado específico do banco de dados.

Para listar todas as chaves, execute o seguinte comando:

certutil -K -d database_directory

Por exemplo:

certutil -K -d $HOME/nssdb/
certutil: Checking token "NSS Certificate DB" in slot "NSS User Private Key and Certificate Services"
Enter Password or Pin for "NSS Certificate DB":
< 0> rsa      35f4555f329c1490b3570c9d36e1ec56f2329f08   NSS Certificate DB:example_test
< 1> rsa      303936d20b3522e9293b75db3dc48f77c1871767   NSS Certificate DB:example_test2

Para mostrar uma chave pública no formato PEM, execute o seguinte comando:

certutil -L -d database_directory -a -n nickname

Por exemplo:

certutil -L -d $HOME/nssdb/ -a -n example_test
-----BEGIN CERTIFICATE-----
...[certificate text]
-----END CERTIFICATE-----

Para exportar um certificado e uma chave para um único arquivo PKCS #12, execute o seguinte comando:
```
pk12util -o certs.p12 -n example_test -d sql:database_directory
```
Para alterar um certificado, use a opção -M. Por exemplo, o seguinte altera os argumentos de confiança de C,C,C para P,P,P para o certificado example_test:
```
$ certutil -d database_directory -M -t "P,P,P" -n example_test
```

Para obter mais informações, consulte as páginas do manual certutil(1) e pk12util(1) e o projeto de código aberto NSS em https://firefox-source-docs.mozilla.org/security/nss/index.html.

Java

Descreve ações comuns de ferramentas-chave para inspecionar armazenamentos de chaves, solicitar certificados e importar cadeias de CA.

A maioria dos aplicativos Java usa o armazenamento de chaves fornecido com o JDK para armazenar chaves criptográficas, informações da cadeia de certificados X.509 e certificados confiáveis. O armazenamento de chaves JDK padrão no Oracle Linux é o arquivo /etc/pki/java/cacerts. Você pode usar o comando keytool para gerar, instalar e gerenciar certificados no armazenamento de chaves Java.

Os exemplos a seguir mostram como você pode usar o comando keytool.

Liste o conteúdo do armazenamento de chaves, /etc/pki/java/cacerts:
```
sudo keytool -list [-v] -keystore /etc/pki/java/cacerts
```
A senha padrão do armazenamento de chaves é changeit. Altere essa senha assim que possível. Se especificada, a opção verbosa -v exibirá informações detalhadas.
Altere a senha de um armazenamento de chaves, por exemplo, /etc/pki/java/cacerts:
```
sudo keytool -storepasswd -keystore /etc/pki/java/cacerts
```
Crie um armazenamento de chaves (keystore.jks).
Ao criar uma área de armazenamento de chaves, você pode:
- Gerencie pares de chaves públicas e privadas e certificados de entidades em que você confia.
- Gere um par de chaves pública e privada usando o algoritmo RSA e um comprimento de chave de 3072 bits.
- Crie um certificado autoassinado que inclua as informações de chave pública e nome distinto especificado.
```
sudo keytool -genkeypair -alias engineering -keyalg RSA -keysize 3072 \
-dname "CN=www.unserdom.com, OU=Eng, O=Unser Dom Corp, C=US, ST=Ca, L=Sunnydale" \
-keypass pkpassword -keystore keystore.jks \
-storepass storepassword -validity 100
```
No comando, pkpassword é a senha da chave privada e storepassword é a senha do armazenamento de chaves. Neste exemplo, o certificado é válido por 100 dias e está associado à chave privada em uma entrada do armazenamento de chaves que tem o alias engineering.
Exibe o conteúdo de um arquivo de certificado em um formato legível por humanos:
```
sudo keytool -printcert [-v] -file cert.cer
```
Se especificada, a opção verbosa -v exibirá informações detalhadas.
Gere um CSR no arquivo carequest.csr para envio a uma CA:
```
sudo keytool -certreq -alias engineering -keystore keystore.jks \
-storepass storepassword -file carequest.csr
```
A CA assina e retorna um certificado ou uma cadeia de certificados que autentica a chave pública.
Importe o certificado raiz ou a cadeia de certificados para a CA do arquivo ACME.cer para o armazenamento de chaves keystore.jks e atribua a ele o alias acmeca:
```
sudo keytool -importcert -alias acmeca [-trustcacerts] -file ACME.cer \
-keystore keystore.jks -storepass storepassword
```
Se especificado, a opção -trustcacerts instrui keytool a adicionar o certificado somente se ele puder validar a cadeia de confiança em relação aos certificados de CA raiz existentes na área de armazenamento de chaves cacerts. Ou você pode usar o comando keytool -printcert para verificar se a impressão digital do certificado corresponde à impressão digital que a CA publica.
Importe o certificado assinado para a organização depois de recebê-lo da CA:
```
sudo keytool -importcert -v -trustcacerts -alias engineering -file ACMEdom.cer \
-keystore keystore.jks -storepass storepassword
```
Neste exemplo, o arquivo que contém o certificado é ACMEdom.cer. A opção -alias especifica a entrada da primeira entidade na cadeia de certificados raiz da CA. O certificado assinado é adicionado à frente da cadeia e se torna a entidade que é endereçada pelo nome do alias.

Exclua o certificado com o alias aliasname do armazenamento de chaves keystore.jks:

sudo keytool -delete -alias aliasname -keystore keystore.jks -storepass storepassword

Exporte o certificado com o alias aliasname como um arquivo de formato PKCS7 binário, que inclui a cadeia de certificados e o certificado emitido:
```
sudo keytool -exportcert -noprompt -alias aliasname -file output.p7b \
-keystore keystore.jks -storepass storepassword
```
Exporte o certificado com o alias aliasname como um arquivo de texto codificado base64 (também conhecido como PEM ou RFC 1421).
```
sudo keytool -exportcert -noprompt -rfc -alias aliasname -file output.pem \
-keystore keystore.jks -storepass storepassword
```
Para uma cadeia de certificados, o arquivo inclui apenas o primeiro certificado da cadeia, que autentica a chave pública da entidade com alias.

Para obter mais informações, consulte a página do manual keytool(1).

Documentação do Oracle Cloud Infrastructure

Definindo TLS/SSL com Outras Ferramentas

NúTLS

NSS

Java