One place for hosting & domains

      Como instalar e configurar uma autoridade de certificação (CA) no Ubuntu 20.04


      Introdução

      Uma autoridade de certificação (CA, do inglês Certificate Authority) é uma entidade responsável por emitir certificados digitais para verificar identidades na internet. Embora as CAs públicas sejam uma escolha popular para a verificação da identidade de sites e outros serviços oferecidos ao público em geral, as CAs privadas são normalmente usadas para grupos fechados e serviços privados.

      A criação de uma autoridade de certificação privada permitirá que você configure, teste e execute programas que exigem conexões criptografadas entre um cliente e um servidor. Com uma CA privada, você pode emitir certificados para usuários, servidores, ou programas e serviços individuais em sua infraestrutura.

      Alguns exemplos de programas no Linux que usam sua própria CA privada são o OpenVPN e o Puppet. Você também pode configurar seu servidor Web para que use certificados emitidos por uma CA privada, de forma a fazer com que os ambientes de desenvolvimento e de preparo correspondam aos servidores de produção que usam o TLS para criptografar conexões.

      Neste guia, vamos aprender como configurar uma autoridade de certificação privada em um servidor Ubuntu 20.04. Além disso, aprenderemos como gerar e assinar um certificado de teste usando sua nova CA. Você também aprenderá como importar o certificado público do servidor da CA para o armazenamento de certificados do seu sistema operacional. Dessa forma, poderá verificar a cadeia de confiança entre a CA e os servidores remotos ou usuários. Por fim, aprenderá a como revogar certificados e distribuir uma Lista de revogação de certificados para garantir que apenas usuários e sistemas autorizados possam usar serviços que dependam da sua CA.

      Pré-requisitos

      Para completar este tutorial, você precisará de acesso a um servidor Ubuntu 20.04 para hospedar seu servidor CA. Você precisará configurar um usuário não root com privilégios sudo antes de iniciar este guia. Você pode seguir nosso guia de configuração inicial do servidor Ubuntu 20.04 para configurar um usuário com as permissões apropriadas. O tutorial em questão também irá configurar um firewall, que assumimos que esteja em funcionamento durante todo este guia.

      Este servidor será chamado de Servidor CA ao longo deste tutorial.

      Certifique-se de que o Servidor CA é um sistema autônomo. Ele será usado apenas para importar, assinar e revogar solicitações de certificado. Ele não deve executar nenhum outro serviço e, de preferência, deve ficar offline ou completamente desligado quando você não estiver trabalhando ativamente com sua CA.

      Nota: a última seção deste tutorial é opcional caso queira aprender sobre a assinatura e revogação de certificados. Caso escolha completar esses passos de prática, você precisará de um segundo servidor Ubuntu 20.04. É possível também usar seu próprio computador Linux local executando o Ubuntu ou o Debian, ou distribuições derivadas de qualquer um deles.

      Passo 1 — Instalando o Easy-RSA

      A primeira tarefa neste tutorial é instalar o conjunto de scripts easy-rsa em seu Servidor CA. O easy-rsa é uma ferramenta de gerenciamento de autoridade de certificação que você usará para gerar uma chave privada e um certificado de raiz público. Em seguida, você usará eles para assinar solicitações de clientes e servidores que dependerão da sua CA.

      Faça login no seu Servidor CA com o usuário sudo não raiz que você criou durante os passos de configuração inicial e execute o seguinte:

      • sudo apt update
      • sudo apt install easy-rsa

      Será solicitado que você baixe o pacote e instale-o. Pressione y para confirmar que deseja instalar o pacote.

      Neste ponto, você tem tudo o que precisa configurado e pronto para usar o Easy-RSA. No próximo passo, você criará uma Infraestrutura de chaves públicas e, em seguida, começará a compilar sua autoridade de certificação.

      Passo 2 — Preparando um diretório de infraestrutura de chaves públicas

      Agora que você instalou easy-rsa, é hora de criar uma Infraestrutura de chaves públicas (PKI, do inglês Public Key Infrastructure) esqueleto no Servidor CA. Certifique-se de que você ainda está logado como seu usuário não raiz e crie um diretório easy-rsa. Certifique-se de que você não esteja usando o sudo para executar nenhum dos comandos a seguir, pois seu usuário normal deve gerenciar e interagir com a CA sem privilégios elevados.

      Isso criará um novo diretório chamado easy-rsa em sua pasta inicial. Usaremos este diretório para criar links simbólicos apontando para os arquivos de pacotes do easy-rsa que instalamos no passo anterior. Esses arquivos estão localizados na pasta /usr/share/easy-rsa no Servidor CA.

      Crie os links simbólicos com o comando ln:

      • ln -s /usr/share/easy-rsa/* ~/easy-rsa/

      Nota: embora outros guias possam instruí-lo a copiar os arquivos de pacotes do easy-rsa para o seu diretório PKI, este tutorial adota uma abordagem com links simbólicos. Como resultado, todas as atualizações realizadas no pacote easy-rsa serão refletidas automaticamente nos scripts do seu PKI.

      Para restringir o acesso ao seu novo diretório PKI, certifique-se de que apenas o proprietário pode acessá-lo usando o comando chmod:

      • chmod 700 /home/sammy/easy-rsa

      Por fim, inicialize o PKI dentro do diretório easy-rsa:

      • cd ~/easy-rsa
      • ./easyrsa init-pki

      Output

      init-pki complete; you may now create a CA or requests. Your newly created PKI dir is: /home/sammy/easy-rsa/pki

      Após completar essa seção, você tem um diretório que contém todos os arquivos necessários para criar uma autoridade de certificação. Na próxima seção, você criará a chave privada e o certificado público para sua CA.

      Passo 3 — Criando uma autoridade de certificação

      Antes de criar a chave e certificado privados do seu CA, você precisa criar e preencher um arquivo chamado vars com alguns valores padrão. Primeiro, você usará o cd para entrar no diretório do easy-rsa. Depois disso, criará e editará o arquivo vars com o nano ou o editor de texto de sua preferência.

      Assim que o arquivo for aberto, cole as seguintes linhas e edite cada valor destacado para que reflitam as informações da sua própria organização. A parte importante aqui é garantir que você não deixe nenhum dos valores em branco:

      ~/easy-rsa/vars

      set_var EASYRSA_REQ_COUNTRY "US" set_var EASYRSA_REQ_PROVINCE "NewYork" set_var EASYRSA_REQ_CITY "New York City" set_var EASYRSA_REQ_ORG "DigitalOcean" set_var EASYRSA_REQ_EMAIL "admin@example.com" set_var EASYRSA_REQ_OU "Community" set_var EASYRSA_ALGO "ec" set_var EASYRSA_DIGEST "sha512"

      Quando você terminar, salve e feche o arquivo. Caso esteja usando o nano, faça isso pressionando CTRL+X, depois Y e ENTER para confirmar. Você está pronto para compilar sua CA.

      Para criar o par de chaves raiz público e privado para sua autoridade de certificação, execute novamente o comando ./easy-rsa. Desta vez, com a opção build-ca:

      No resultado, você verá algumas linhas sobre a versão do OpenSSL e será solicitado a digitar uma frase secreta para o seu par de chaves. Certifique-se de escolher uma frase secreta forte e digite-a em um local seguro. Será necessário digitar a frase secreta sempre que precisar interagir com sua CA. Por exemplo, para assinar ou revogar um certificado.

      Será solicitado que você confirme o nome comum (CN, do inglês Common Name) para sua CA. O CN é o nome usado para se referir a esta máquina no contexto da autoridade de certificados. Você pode digitar qualquer string de caracteres para o nome comum da CA mas, para simplificar as coisas, pressione ENTER para aceitar o nome padrão.

      Output

      . . . Enter New CA Key Passphrase: Re-Enter New CA Key Passphrase: . . . Common Name (eg: your user, host, or server name) [Easy-RSA CA]: CA creation complete and you may now import and sign cert requests. Your new CA certificate file for publishing is at: /home/sammy/easy-rsa/pki/ca.crt

      Nota: se você não quiser ser solicitado a colocar uma senha sempre que interagir com sua CA, é possível executar o comando build-ca com a opção nopass, desta maneira:

      • ./easyrsa build-ca nopass

      Agora, você tem dois arquivos importantes — o ~/easy-rsa/pki/ca.crt e o ~/easy-rsa/pki/private/ca.key — que constituem os componentes públicos e privados de uma autoridade de certificação.

      • O ca.crt é o arquivo de certificado público da CA. Usuários, servidores e clientes usarão este certificado para comprovarem se eles fazem parte da mesma rede de confiança. Todos os usuários e servidores que usam sua CA precisarão de uma cópia deste arquivo. Todas as partes dependerão do certificado público para garantir que um terceiro não esteja se passando por um sistema e executando um ataque Man-in-the-middle.

      • A ca.key é a chave privada que a CA usa para assinar chaves e certificados para servidores e clientes. Se um invasor ganhar acesso à sua CA e, por sua vez, seu arquivo ca.key, será necessário destruir sua CA. Esse é o motivo pelo qual seu arquivo ca.key deve estar apenas na sua máquina CA e que, idealmente, sua máquina CA deve ser mantida off-line quando não estiver assinando pedidos de certificado como uma medida de segurança extra.

      Com isso, sua CA está funcionando e está pronta para ser usada para assinar solicitações de certificado, além de revogar certificados.

      Passo 4 — Distribuindo seu certificado público da sua autoridade de certificação

      Agora, sua CA está configurada e pronta para agir como uma raiz de confiança para todos os sistemas que quiser configurar para usá-la. Você pode adicionar o certificado da CA aos seus servidores OpenVPN, servidores Web, servidores de e-mail, e assim por diante. Qualquer usuário ou servidor que precise verificar a identidade de outro usuário ou servidor em sua rede deve ter uma cópia do arquivo ca.crt importada para o armazenamento de certificados do seu sistema operacional.

      Para importar o certificado público da CA em um segundo sistema Linux, como outro servidor ou um computador local, obtenha primeiro uma cópia do arquivo ca.crt do seu servidor CA. Você pode usar o comando cat para gerar isso como resultado em um terminal para, em seguida, copiar e colá-lo em um arquivo em um segundo computador que está importando o certificado. Você também pode usar ferramentas como o scp e o rsync para transferir o arquivo entre os sistemas. No entanto, usaremos o copiar e colar com o nano neste passo, pois isso funcionará em todos os sistemas.

      Usando seu usuário não raiz no Servidor CA, execute o comando a seguir:

      • cat ~/easy-rsa/pki/ca.crt

      Haverá um resultado em seu terminal que é parecido com este:

      Output

      -----BEGIN CERTIFICATE----- MIIDSzCCAjOgAwIBAgIUcR9Crsv3FBEujrPZnZnU4nSb5TMwDQYJKoZIhvcNAQEL BQAwFjEUMBIGA1UEAwwLRWFzeS1SU0EgQ0EwHhcNMjAwMzE4MDMxNjI2WhcNMzAw . . . . . . -----END CERTIFICATE-----

      Copie tudo, incluindo as linhas -----BEGIN CERTIFICATE----- e -----END CERTIFICATE----- e os traços.

      Em seu segundo sistema Linux, use o nano ou o editor de texto de sua preferência para abrir um arquivo chamado /tmp/ca.crt:

      Cole o conteúdo que acabou de copiar do Servidor CA no editor. Quando você terminar, salve e feche o arquivo. Caso esteja usando o nano, faça isso pressionando CTRL+X, então Y e ENTER para confirmar.

      Agora que você tem uma cópia do arquivo ca.crt em seu segundo sistema Linux, é hora de importar o certificado para o armazenamento de certificados de seu sistema operacional.

      Em sistemas baseados no Ubuntu ou Debian, execute os seguintes comandos com seu usuário não-root para importar o certificado:

      Ubuntu and Debian derived distributions

      • sudo cp /tmp/ca.crt /usr/local/share/ca-certificates/
      • sudo update-ca-certificates

      Para importar o certificado do Servidor CA em um sistema baseado em CentOS, Fedora ou RedHat, copie e cole o conteúdo do arquivo no sistema, assim como no exemplo anterior, em um arquivo chamado /tmp/ca.crt. Em seguida, copie o certificado para /etc/pki/ca-trust/source/anchors/. Depois disso, execute o comando update-ca-trust.

      CentOS, Fedora, RedHat distributions

      • sudo cp /tmp/ca.crt /etc/pki/ca-trust/source/anchors/
      • sudo update-ca-trust

      Agora, seu segundo sistema Linux confiará em qualquer certificado que tenha sido assinado pelo servidor CA.

      Nota: se estiver usando sua CA com servidores Web e usar o Firefox como navegador, será necessário importar o certificado público ca.crt para o Firefox diretamente. O Firefox não usa o armazenamento de certificados do sistema operacional local. Para mais detalhes sobre como adicionar o certificado da sua CA ao Firefox, consulte este artigo de suporte do Mozilla sobre Como configurar autoridades de certificação (CAs) no Firefox.

      Caso esteja usando sua CA para integrar com um ambiente Windows ou computadores desktop, consulte a documentação sobre como usar o certutil.exe para instalar um certificado CA.

      Se estiver usando este tutorial como um pré-requisito para outro tutorial, ou já estiver familiarizado com como assinar e revogar certificados, você pode parar aqui. Caso queira aprender mais sobre como assinar e revogar certificados, então a seguinte seção opcional explicará cada processo detalhadamente.

      (Opcional) — Criando solicitações de assinatura de certificado e revogando certificados

      As seções a seguir do tutorial são opcionais. Caso tenha completado todos os passos anteriores, então você possui uma autoridade de certificação totalmente configurada e funcional que pode ser usada como pré-requisito para outros tutoriais. Você pode importar o arquivo ca.crt da sua CA e verificar certificados em sua rede que foram assinados por sua CA.

      Se quiser praticar e aprender mais sobre como assinar solicitações de certificado e como revogar certificados, então essas seções opcionais explicarão como ambos os processos funcionam.

      (Opcional) — Criando e assinando uma solicitação de certificado de prática

      Agora que você tem uma CA pronta para ser usada, pode praticar a geração de uma chave privada e uma solicitação de certificado para se familiarizar com o processo de assinatura e distribuição.

      Uma solicitação de assinatura de certificado (CSR, do inglês Certificate Signing Request) consiste em três partes: uma chave pública, identificar informações sobre o sistema solicitante e uma assinatura da solicitação em si, que é criada usando a chave privada do solicitante. A chave privada será mantida em segredo e será usada para criptografar informações que qualquer um com o certificado público assinado pode, em seguida, decodificar.

      Os passos a seguir serão executados em seu segundo sistema Ubuntu ou Debian, ou em uma distribuição derivada de qualquer um deles. Ele pode ser outro servidor remoto, ou uma máquina Linux local, como um notebook ou um computador desktop. Como o easy-rsa não vem disponível por padrão em todos os sistemas, usaremos a ferramenta openssl para criar uma chave privada e certificado de prática.

      O openssl vem geralmente instalado por padrão na maioria das distribuições do Linux. Porém, para garantir que esse seja o caso, execute o seguinte em seu sistema:

      • sudo apt update
      • sudo apt install openssl

      Quando for solicitado a instalar o openssl, digite y para continuar com os passos da instalação. Agora, você está pronto para criar uma CSR de prática com o openssl.

      O primeiro passo que você precisa completar para criar uma CSR é gerar uma chave privada. Para criar uma chave privada usando o openssl, crie um diretório practice-csr e, em seguida, gere uma chave dentro dele. Faremos essa solicitação para um servidor ficcional chamado sammy-server, em vez de criar um certificado que seja usado para identificar um usuário ou outra CA.

      • mkdir ~/practice-csr
      • cd ~/practice-csr
      • openssl genrsa -out sammy-server.key

      Output

      Generating RSA private key, 2048 bit long modulus (2 primes) . . . . . . e is 65537 (0x010001)

      Agora que você tem uma chave privada, pode criar uma CSR correspondente, usando novamente o utilitário openssl. Será solicitado que você preencha alguns campos como o Country (País), o State (Estado) e o City (Cidade). Você pode digitar . se quiser deixar um campo em branco, mas fique ciente de que se essa fosse uma CSR real, seria melhor usar os valores corretos para sua localização e organização:

      • openssl req -new -key sammy-server.key -out sammy-server.req

      Output

      . . . ----- Country Name (2 letter code) [XX]:US State or Province Name (full name) []:New York Locality Name (eg, city) [Default City]:New York City Organization Name (eg, company) [Default Company Ltd]:DigitalOcean Organizational Unit Name (eg, section) []:Community Common Name (eg, your name or your server's hostname) []:sammy-server Email Address []: Please enter the following 'extra' attributes to be sent with your certificate request A challenge password []: An optional company name []:

      Se quiser adicionar esses valores automaticamente como parte da invocação do openssl, ao invés de usar o prompt interativo, você pode passar o argumento -subj para o OpenSSL. Certifique-se de editar os valores destacados para que correspondam à sua localização, organização e nome do servidor de prática:

      • openssl req -new -key sammy-server.key -out server.req -subj
      • /C=US/ST=New York/L=New York City/O=DigitalOcean/OU=Community/CN=sammy-server

      Para verificar o conteúdo de uma CSR, você pode ler em um arquivo de solicitação com o openssl e examinar os campos dentro dele:

      • openssl req -in sammy-server.req -noout -subject

      Output

      subject=C = US, ST = New York, L = New York City, O = DigitalOcean, OU = Community, CN = sammy-server

      Assim que estiver satisfeito com as informações no seu certificado de prática, copie o arquivo sammy-server.req para seu servidor CA usando o scp:

      • scp sammy-server.req sammy@your_ca_server_ip:/tmp/sammy-server.req

      Neste passo, você gerou uma solicitação de assinatura de certificado para um servidor fictício chamado sammy-server. Em um cenário real, a solicitação poderia vir de algo como um servidor Web de preparo ou desenvolvimento que precisa de um certificado TLS para a testagem; ou poderia ter vindo de um servidor OpenVPN que está solicitando um certificado para que os usuários possam se conectar a uma VPN. No próximo passo, vamos seguir adiante para a solicitação de assinatura de certificado usando a chave privada do Servidor CA.

      (Opcional) — Assinando uma CSR

      No passo anterior, você criou uma solicitação de certificado e chave de prática para um servidor fictício. Você copiou ela para o diretório /tmp em seu servidor CA, simulando o processo que você usaria se tivesse clientes ou servidores reais enviando a você solicitações de CSR que precisassem ser assinadas.

      Continuando com o cenário fictício, o Servidor CA precisa agora importar o certificado de prática e assiná-lo. Assim que uma solicitação de certificado é validada pela CA e redirecionada para um servidor, os clientes que confiam na autoridade de certificação também poderão confiar no certificado recém-emitido.

      Vamos operar dentro do PKI da CA onde o utilitário easy-rsa está disponível. Sendo assim, os passos de assinatura usarão o utilitário easy-rsa para facilitar as coisas, ao invés de usar o openssl diretamente como fizemos no exemplo anterior.

      O primeiro passo para assinar a CSR fictícia é importar a solicitação de certificado usando o script easy-rsa:

      • cd ~/easy-rsa
      • ./easyrsa import-req /tmp/sammy-server.req sammy-server

      Output

      . . . The request has been successfully imported with a short name of: sammy-server You may now use this name to perform signing operations on this request.

      Agora, você pode assinar a solicitação, executando o script easyrsa com a opção sign-req, seguida pelo tipo de solicitação e o nome comum incluído no CSR. O tipo de solicitação pode ser de um cliente, server ou ca. Já que estamos praticando com um certificado para um servidor ficcional, certifique-se de usar o tipo de solicitação server:

      • ./easyrsa sign-req server sammy-server

      No resultado, você será solicitado a verificar se o pedido vem de uma fonte confiável. Digite yes, então pressione ENTER para confirmar:

      Output

      You are about to sign the following certificate. Please check over the details shown below for accuracy. Note that this request has not been cryptographically verified. Please be sure it came from a trusted source or that you have verified the request checksum with the sender. Request subject, to be signed as a server certificate for 3650 days: subject= commonName = sammy-server Type the word 'yes' to continue, or any other input to abort. Confirm request details: yes . . . Certificate created at: /home/sammy/easy-rsa/pki/issued/sammy-server.crt

      Caso tenha criptografado sua chave CA, você será solicitado a colocar sua senha neste ponto.

      Com esses passos completos, você assinou a CSR sammy-server.req usando a chave privada do Servidor CA em /home/sammy/easy-rsa/pki/private/ca.key. O arquivo sammy-server.crt resultante contém a chave pública de criptografia do servidor de prática, além de uma nova assinatura do Servidor CA. O objetivo da assinatura é dizer a todos que confiam na CA que eles também podem confiar no certificado do sammy-server.

      Se essa solicitação fosse para um servidor real, como um servidor Web ou um servidor VPN, o último passo no Servidor CA seria distribuir os novos arquivos sammy-server.crt e ca.crt do Servidor CA para o servidor remoto que fez a solicitação da CSR:

      • scp pki/issued/sammy-server.crt sammy@your_server_ip:/tmp
      • scp pki/ca.crt sammy@your_server_ip:/tmp

      Neste ponto, você poderia usar o certificado emitido com algo com um servidor Web, um VPN, uma ferramenta de gerenciamento de configuração, sistema de banco de dados, ou para fins de autenticação de cliente.

      (Opcional) — Revogando um certificado

      De vez em quando, você pode precisar revogar um certificado para evitar que um usuário ou servidor o use. Talvez o notebook de alguém tenha sido roubado, um servidor Web foi comprometido, ou um empregado ou contratante deixou sua organização.

      Para revogar um certificado, o processo geral segue estes passos:

      1. Revogue o certificado com o comando ./easyrsa revoke client_name.
      2. Gere uma nova CRL com o comando ./easyrsa gen-crl.
      3. Transfira o arquivo crl.pem atualizado para o servidor ou servidores que dependem da sua CA. Nesses sistemas, copie-o para o diretório ou diretórios necessários para os programas que fazem referência a ele.
      4. Reinicie todos os serviços que usam sua CA e o arquivo de CRL.

      Você pode usar esse processo para revogar qualquer certificado que você tenha emitido previamente. Vamos analisar cada passo detalhadamente nas seções a seguir, começando pelo comando revoke (revogar).

      Revogando um certificado

      Para revogar um certificado, navegue para o diretório easy-rsa em seu servidor CA:

      Em seguida, execute o script easyrsa com a opção revoke, seguida do nome do cliente que você deseja revogar. Seguindo o exemplo de prática acima, o nome comum do certificado é sammy-server:

      • ./easyrsa revoke sammy-server

      Isso irá pedir que você confirme a revogação digitando yes:

      Output

      Please confirm you wish to revoke the certificate with the following subject: subject= commonName = sammy-server Type the word 'yes' to continue, or any other input to abort. Continue with revocation: yes . . . Revoking Certificate 8348B3F146A765581946040D5C4D590A . . .

      Observe o valor destacado na linha Revoking Certificate (Revogando Certificado). Este valor é o número de série único do certificado que está sendo revogado. Se quiser examinar a lista de revogação no último passo desta seção para verificar se o certificado está nela, você precisará deste valor.

      Após confirmar a ação, a CA revogará o certificado. No entanto, os sistemas remotos que dependem da CA não têm como verificar se algum certificado foi revogado. Usuários e servidores ainda poderão usar o certificado até que a Lista de revogação de certificado (CRL, do inglês Certificate Revocation List) da CA seja distribuída a todos os sistemas que dependem da CA.

      No próximo passo, você gerará uma CRL ou atualizará um arquivo crl.pem existente.

      Gerando uma lista de revogação de certificado

      Agora que você revogou um certificado, é importante atualizar a lista de certificados revogados em seu servidor CA. Assim que tiver uma lista de revogação atualizada, você será capaz de dizer quais usuários e sistemas têm certificados válidos em sua CA.

      Para gerar uma CRL, execute o comando easy-rsa com a opção gen-crl, ainda estando dentro do diretório ~/easy-rsa:

      Se você tiver usado uma frase secreta ao criar seu arquivo ca.key, você será solicitado a digitá-la. O comando gen-crl gerará um arquivo chamado crl.pem, que contém a lista atualizada de certificados revogados para essa CA.

      Em seguida, será necessário transferir o arquivo crl.pem atualizado para todos os servidores e clientes que dependem dessa CA sempre que você executar o comando gen-crl. Caso contrário, os clientes e sistemas ainda poderão acessar os serviços e sistemas que usam sua CA, já que esses serviços precisam saber sobre o status revogado do certificado.

      Transferindo uma lista de revogação de certificado

      Agora que você gerou uma CRL em seu servidor CA, você precisa transferi-la para os sistemas remotos que dependem da sua CA. Para transferir esse arquivo para os seus servidores, use o comando scp.

      Nota: este tutorial explica como gerar e distribuir uma CRL manualmente. Embora existam métodos mais robustos e automatizados para distribuir e verificar listas de revogação, como o OCSP-Stapling, a configuração desses métodos vai além do âmbito deste artigo.

      Certifique-se de que você está logado em seu servidor CA com seu usuário não raiz e execute o que vem a seguir, substituindo your_server_ip pelo IP ou nome DNS do seu próprio servidor:

      • scp ~/easy-rsa/pki/crl.pem sammy@your_server_ip:/tmp

      Agora que o arquivo está no sistema remoto, o último passo é atualizar todos os serviços com a nova cópia da lista de revogação.

      Atualizando os serviços que suportam uma CRL

      Listar os passos que você precisa seguir para atualizar os serviços que usam o arquivo crl.pem vai além do âmbito deste tutorial. De maneira geral, será necessário copiar o arquivo crl.pem para o local que o serviço espera e, em seguida, reiniciá-lo usando o systemctl.

      Assim que tiver atualizado seus serviços com o novo arquivo crl.pem, seus serviços serão capazes de rejeitar conexões de clientes ou servidores que estão usando um certificado revogado.

      Examinando e verificando o conteúdo de uma CRL

      Se quiser examinar um arquivo de CRL, para, por exemplo, confirmar uma lista de certificados revogados, use o comando openssl de dentro do seu diretório easy-rsa em seu servidor CA:

      • cd ~/easy-rsa
      • openssl crl -in pki/crl.pem -noout -text

      Você também pode executar este comando em qualquer servidor ou sistema que tenha a ferramenta openssl instalada com uma cópia do arquivo crl.pem. Por exemplo, se você transferiu o arquivo crl.pem para seu segundo sistema e quer verificar se o certificado sammy-server foi revogado, pode usar um comando openssl parecido com o seguinte, substituindo o número de série que você observou anteriormente quando revogou o certificado pelo destacado:

      • openssl crl -in /tmp/crl.pem -noout -text |grep -A 1 8348B3F146A765581946040D5C4D590A

      Output

      Serial Number: 8348B3F146A765581946040D5C4D590A Revocation Date: Apr 1 20:48:02 2020 GMT

      Observe como o comando grep é usado para verificar se o número de série único que você observou no passo da revogação está presente. Agora, você pode verificar o conteúdo da sua lista de revogação de certificado em qualquer sistema que dependa dela para restringir o acesso a usuários e serviços.

      Conclusão

      Neste tutorial, você criou uma autoridade de certificação privada, usando o pacote Easy-RSA em um servidor Ubuntu 20.04 independente. Você aprendeu como o modelo de confiança funciona entre as partes que dependem da CA. Você também criou e assinou uma solicitação de assinatura de certificado (CSR) para um servidor de prática e, em seguida, aprendeu como revogar um certificado. Por fim, aprendeu como gerar e distribuir uma lista de revogação de certificado (CRL) para qualquer sistema que dependa da sua CA para garantir que os usuários ou servidores que não devem acessar serviços sejam impedidos de fazê-lo.

      Agora, você é capaz de emitir certificados para os usuários e usá-los com serviços, tal como o OpenVPN. Você também pode usar sua CA para configurar os servidores Web de desenvolvimento e de preparo, com certificados para proteger seus ambientes de não produção. Usar uma CA com certificados TLS durante o desenvolvimento pode ajudar a garantir que seu código e ambiente correspondam ao seu ambiente de produção da melhor maneira possível.

      Se quiser aprender mais sobre como usar o OpenSSL, nosso tutorial Fundamentos do OpenSSL: trabalhando com certificados SSL, chaves privadas e CSRs têm muitas informações adicionais para que você se familiarize com os fundamentos do OpenSSL.



      Source link

      Uma Introdução ao Gerenciamento de Configuração


      Introdução

      Em um aspecto mais amplo, o gerenciamento de configuração (GC) refere-se ao processo de manipular sistematicamente as alterações em um sistema, de maneira a manter a integridade ao longo do tempo. Embora esse processo não tenha sido originado no setor de TI, o termo é amplamente usado para se referir ao gerenciamento de configuração de servidor.

      A automação desempenha um papel essencial no gerenciamento de configuração de servidor. É o mecanismo usado para fazer o servidor alcançar um estado desejável, definido anteriormente por scripts de provisionamento usando a linguagem e os recursos específicos de uma ferramenta. A automação é, de fato, o coração do gerenciamento de configurações de servidores, e é por isso que é comum também se referir às ferramentas de gerenciamento de configuração como Ferramentas de Automação ou Ferramentas de Automação de TI.

      Outro termo comum usado para descrever os recursos de automação implementados pelas ferramentas de gerenciamento de configuração é Orquestração de Servidor ou Orquestração de TI, uma vez que essas ferramentas geralmente são capazes de gerenciar de um a centenas de servidores a partir de uma máquina controladora central.

      Existem várias ferramentas de gerenciamento de configuração disponíveis no mercado. Puppet, Ansible, Chef e Salt são escolhas populares. Embora cada ferramenta tenha suas próprias características e funcione de maneiras ligeiramente diferentes, todas elas são orientadas pelo mesmo propósito: garantir que o estado do sistema corresponda ao estado descrito pelos seus scripts de provisionamento.

      Benefícios do Gerenciamento de Configuração para Servidores

      Embora o uso do gerenciamento de configuração geralmente exija mais planejamento e esforço iniciais do que a administração manual do sistema, todas as infraestruturas de servidor, exceto as mais simples, serão aprimoradas pelos benefícios que ele oferece. Para citar alguns:

      Provisionamento Rápido de Novos Servidores

      Sempre que um novo servidor precisa ser deployado, uma ferramenta de gerenciamento de configuração pode automatizar a maior parte, se não todo, do processo de provisionamento para você. A automação torna o provisionamento muito mais rápido e eficiente, pois permite que tarefas tediosas sejam executadas com mais rapidez e precisão do que qualquer ser humano poderia. Mesmo com a documentação adequada e completa, o deployment manual de um servidor web, por exemplo, pode levar horas em comparação a alguns minutos com o gerenciamento/automação da configuração.

      Recuperação Rápida de Eventos Críticos

      Com o provisionamento rápido, vem outro benefício: recuperação rápida de eventos críticos. Quando um servidor fica offline devido a circunstâncias desconhecidas, pode levar várias horas para se auditar adequadamente o sistema e descobrir o que realmente aconteceu. Em cenários como esse, fazer o deploy de um servidor substituto geralmente é a maneira mais segura de colocar seus serviços online novamente enquanto uma inspeção detalhada é feita no servidor afetado. Com o gerenciamento e a automação da configuração, isso pode ser feito de maneira rápida e confiável.

      Não mais Servidores Snowflake

      À primeira vista, a administração manual do sistema pode parecer uma maneira fácil de fazer deploy e corrigir rapidamente os servidores, mas isso geralmente tem um preço. Com o tempo, pode se tornar extremamente difícil saber exatamente o que está instalado em um servidor e quais alterações foram feitas quando o processo não é automatizado. Os hotfixes manuais, os ajustes de configuração e as atualizações de software podem transformar os servidores em snowflakes exclusivos, difíceis de gerenciar e ainda mais difíceis de replicar. Usando uma ferramenta de GC, o procedimento necessário para lançar um novo servidor ou atualizar um existente estará documentado nos scripts de provisionamento.

      Controle de Versão para o Ambiente do Servidor

      Depois de ter sua configuração do servidor traduzida em um conjunto de scripts de provisionamento, você poderá aplicar ao ambiente do seu servidor muitas das ferramentas e fluxos de trabalho que você normalmente usa para o código-fonte de software.

      Ferramentas de controle de versão como o Git, podem ser usadas para acompanhar as alterações feitas no provisionamento e manter ramificações separadas para as versões antigas dos scripts. Você também pode usar o controle de versão para implementar uma política de code review para os scripts de provisionamento, onde todas as alterações devem ser submetidas como um pull request e aprovadas pelo líder do projeto antes de serem aceitas. Essa prática adicionará consistência extra à sua configuração de infraestrutura.

      Ambientes Replicados

      O gerenciamento de configuração torna trivial replicar ambientes com exatamente o mesmo software e as mesmas configurações. Isso permite que você crie efetivamente um ecossistema de vários estágios, com servidores de produção, desenvolvimento e teste. Você pode até usar máquinas virtuais locais para desenvolvimento, criadas com os mesmos scripts de provisionamento. Essa prática minimizará os problemas causados por discrepâncias no ambiente que ocorrem com frequência quando as aplicações são deployadas na produção ou compartilhadas entre colegas de trabalho com diferentes configurações de máquina (sistema operacional diferente, versões de software e/ou configurações).

      Visão Geral das Ferramentas de Gerenciamento de Configuração

      Embora cada ferramenta de GC tenha seus próprios termos, filosofia e ecossistema, elas geralmente compartilham muitas características e têm conceitos semelhantes.

      A maioria das ferramentas de gerenciamento de configuração usa um modelo de controlador/mestre e node/agente. Essencialmente, o controlador direciona a configuração dos nodes, com base em uma série de instruções ou tasks definidas em seus scripts de provisionamento.

      Abaixo, você encontra os recursos mais comuns presentes na maioria das ferramentas de gerenciamento de configuração para servidores:

      Framework de Automação

      Cada ferramenta de gerenciamento de configuração fornece uma sintaxe específica e um conjunto de recursos que você pode usar para escrever scripts de provisionamento. A maioria das ferramentas possui recursos que tornam sua linguagem semelhante às linguagens de programação convencionais, mas de maneira simplificada. Variáveis, loops e condicionais são recursos comuns fornecidos para facilitar a criação de scripts de provisionamento mais versáteis.

      Comportamento Idempotente

      As ferramentas de gerenciamento de configuração controlam o estado dos recursos para evitar a repetição de tarefas que foram executadas anteriormente. Se um pacote já estiver instalado, a ferramenta não tentará instalá-lo novamente. O objetivo é que, após cada execução de provisionamento, o sistema atinja (ou mantenha) o estado desejado, mesmo que você o execute várias vezes. É isso que caracteriza essas ferramentas como tendo um comportamento idempotente. Esse comportamento não é necessariamente imposto em todos os casos, no entanto.

      Fatos do Sistema (Facts)

      As ferramentas de gerenciamento de configuração geralmente fornecem informações detalhadas sobre o sistema que está sendo provisionado. Esses dados estão disponíveis através de variáveis globais, conhecidas como facts. Eles incluem coisas como interfaces de rede, endereços IP, sistema operacional e distribuição. Cada ferramenta fornecerá um conjunto diferente de facts. Eles podem ser usados para tornar os scripts e templates de provisionamento mais adaptáveis a vários sistemas.

      Sistema de Templates

      A maioria das ferramentas de GC fornecerá um sistema de templates interno que pode ser usado para facilitar a criação de arquivos e serviços de configuração. Os templates geralmente suportam variáveis, loops e condicionais que podem ser usados para maximizar a versatilidade. Por exemplo, você pode usar um template para configurar facilmente um novo virtual host no Apache, enquanto reutiliza o mesmo template para várias instalações de servidores. Em vez de ter apenas valores estáticos codificados, um template deve conter espaços reservados (placeholders) para valores que podem mudar de host para host, como NameServer e DocumentRoot.

      Extensibilidade

      Embora os scripts de provisionamento possam ser muito especializados para as necessidades e demandas de um servidor específico, há muitos casos em que você tem configurações semelhantes de servidor ou partes de uma configuração que podem ser compartilhadas entre vários servidores. A maioria das ferramentas de provisionamento fornecerá maneiras pelas quais você pode reutilizar e compartilhar facilmente pequenos blocos de sua configuração de provisionamento como módulos ou plugins.

      Módulos e plugins de terceiros geralmente são fáceis de encontrar na Internet, especialmente para configurações comuns de servidores, como a instalação de um servidor web PHP. As ferramentas de GC tendem a ter uma comunidade forte criada em torno delas e os usuários são incentivados a compartilhar suas extensões personalizadas. O uso de extensões fornecidas por outros usuários pode economizar muito tempo, além de servir como uma excelente maneira de aprender como outros usuários resolveram problemas comuns usando a ferramenta de sua escolha.

      Escolhendo uma Ferramenta de Gerenciamento de Configuração

      Existem muitas ferramentas de GC disponíveis no mercado, cada uma com um conjunto diferente de recursos e diferentes níveis de complexidade. As escolhas populares incluem Chef, Ansible e Puppet. O primeiro desafio é escolher uma ferramenta que seja adequada às suas necessidades.

      Há algumas coisas que você deve levar em consideração antes de fazer uma escolha:

      Complexidade da Infraestrutura

      A maioria das ferramentas de gerenciamento de configuração requer uma hierarquia mínima composta por uma máquina controladora e um node que será gerenciado por ela. O Puppet, por exemplo, exige que uma aplicação agent seja instalada em cada node e um aplicação master seja instalada na máquina do controlador. O Ansible, por outro lado, possui uma estrutura descentralizada que não requer instalação de software adicional nos nodes, mas depende do SSH para executar as tarefas de provisionamento. Para projetos menores, uma infraestrutura simplificada pode parecer melhor, no entanto, é importante levar em consideração aspectos como escalabilidade e segurança, que podem não ser impostos pela ferramenta.

      Algumas ferramentas podem ter mais componentes e partes móveis, o que pode aumentar a complexidade da sua infraestrutura, impactando na curva de aprendizado e possivelmente aumentando o custo geral de implementação.

      Curva de Aprendizado

      Como mencionado anteriormente neste artigo, as ferramentas de GC fornecem uma sintaxe personalizada, às vezes usando uma linguagem de domínio específico (DSL) e um conjunto de recursos que compõem seu framework de automação. Como nas linguagens de programação convencionais, algumas ferramentas exigem uma curva de aprendizado mais alta para serem dominadas. Os requisitos de infraestrutura também podem influenciar a complexidade da ferramenta e a rapidez com que você poderá ver um retorno do investimento.

      Custo

      A maioria das ferramentas de GC oferece versões gratuitas ou open source, com assinaturas pagas para recursos e serviços avançados. Algumas ferramentas terão mais limitações que outras, portanto, dependendo de suas necessidades específicas e de como sua infraestrutura cresce, você pode acabar tendo que pagar por esses serviços. Você também deve considerar o treinamento como um custo extra em potencial, não apenas em termos monetários, mas também em relação ao tempo necessário para atualizar sua equipe com a ferramenta que você acabou escolhendo.

      Ferramentas Avançadas

      Como mencionado anteriormente, a maioria das ferramentas oferece serviços pagos que podem incluir suporte, extensões e ferramentas avançadas. É importante analisar suas necessidades específicas, o tamanho da sua infraestrutura e se há ou não a necessidade de usar esses serviços. Os painéis de gerenciamento, por exemplo, são um serviço comum oferecido por essas ferramentas e podem facilitar muito o processo de gerenciamento e monitoramento de todos os seus servidores a partir de um ponto central. Mesmo que você ainda não precise desses serviços, considere as opções para uma possível necessidade futura.

      Comunidade e Suporte

      Uma comunidade forte e acolhedora pode ser extremamente útil em termos de suporte e documentação, pois os usuários geralmente ficam felizes em compartilhar seu conhecimento e suas extensões (módulos, plugins e scripts de provisionamento) com outros usuários. Isso pode ser útil para acelerar sua curva de aprendizado e evitar custos extras com suporte ou treinamento pagos.

      Visão Geral das Ferramentas Populares

      A tabela abaixo deve lhe fornecer uma rápida visão geral das principais diferenças entre as três ferramentas de gerenciamento de configuração mais populares disponíveis no mercado atualmente: Ansible, Puppet e Chef.

      Ansible Puppet Chef
      Linguagem do Script YAML DSL personalizada baseada em Ruby Ruby
      Infraestrutura A máquina controladora aplica a configuração nos nodes via SSH O Puppet Master sincroniza a configuração nos Puppet Nodes As Workstations do Chef enviam a configuração para o Chef Server, a partir do qual os nodes do Chef serão atualizados
      Requer software especializado para os nodes Não Sim Sim
      Fornece ponto de controle centralizado Não. Qualquer computador pode ser um controlador Sim, via Puppet Master Sim, via Chef Server
      Terminologia do script Playbook / Roles Manifests / Modules Recipes / Cookbooks
      Ordem de Execução das Tarefas Sequencial Não-sequencial Sequencial

      Próximos Passos

      Até agora, vimos como o gerenciamento de configuração funciona para servidores e o que considerar ao escolher uma ferramenta para criar sua infraestrutura de gerenciamento de configuração. Nos guias subsequentes desta série, teremos uma experiência prática com três ferramentas populares de gerenciamento de configuração: Ansible, Puppet e Chef.

      Para que você possa comparar essas ferramentas por si mesmo, usaremos um exemplo simples de configuração de servidor que deve ser totalmente automatizado por cada ferramenta. Essa configuração consiste em um servidor Ubuntu 18.04 executando o Apache para hospedar uma página web simples.

      Conclusão

      O gerenciamento de configuração pode melhorar drasticamente a integridade dos servidores ao longo do tempo, fornecendo um framework para automatizar processos e acompanhar as alterações feitas no ambiente do sistema. No próximo guia dessa série, veremos como implementar uma estratégia de gerenciamento de configuração na prática usando Ansible como ferramenta.



      Source link

      Uma introdução ao pacote de Strings em Go


      Introdução

      O pacote stringem Go possui várias funções disponíveis para trabalhar com o string data type​​​. Essas funções nos permitem modificar e manipular strings facilmente. Podemos pensar em funções como ações que realizamos nos elementos do nosso código. Funções integradas são aquelas definidas na linguagem de programação Go e ficam prontamente disponíveis para o nosso uso.

      Neste tutorial, avaliaremos várias funções diferentes que podemos usar para trabalhar com as strings em Go.

      Criando strings em letras maiúsculas e minúsculas

      As funções strings.ToUpper e strings.ToLower vão retornar uma string com todas as letras de uma string original convertidas em letras maiúsculas ou minúsculas. Como as strings são tipos de dados imutáveis, a string retornada será uma nova string. Quaisquer caracteres na string que não sejam letras não serão alterados.

      Para converter a string "Sammy Shark" para ser toda em maiúscula, use a função strings.ToUpper:

      ss := "Sammy Shark"
      fmt.Println(strings.ToUpper(ss))
      

      Output

      SAMMY SHARK

      Para converter para minúsculas:

      fmt.Println(strings.ToLower(ss))
      

      Output

      sammy shark

      Como você está usando o pacote strings, primeiro você precisa importá-lo para um programa. Para converter a string em maiúsculas e minúsculas, o programa todo ficaria da seguinte forma:

      package main
      
      import (
          "fmt"
          "strings"
      )
      
      func main() {
          ss := "Sammy Shark"
          fmt.Println(strings.ToUpper(ss))
          fmt.Println(strings.ToLower(ss))
      }
      

      As funções strings.ToUpper e strings.ToLower facilitam a avaliação e comparação de strings, tornando consistente o uso de maiúsculas e minúsculas de ponta a ponta. Por exemplo, se um usuário escreve seu nome com todas as letras minúsculas, ainda assim conseguiremos saber se o nome dele está em nosso banco de dados, comparando-o com uma versão com todas as letras maiúsculas.

      Funções de busca de string

      O pacote strings tem uma série de funções que ajudam a determinar se uma string contém uma sequência específica de caracteres.

      Função Uso
      strings.HasPrefix Procura a string desde o início
      strings.HasSuffix Procura a string a partir do final
      strings.Contains Procura em qualquer lugar na string
      strings.Count Conta quantas vezes a string aparece

      As funções strings.HasPrefix e strings.HasSuffix permitem que você verifique se uma string começa ou termina com um conjunto específico de caracteres.

      Por exemplo, para verificar se a string "Sammy Shark" começa com Sammy e termina com o Shark:

      ss := "Sammy Shark"
      fmt.Println(strings.HasPrefix(ss, "Sammy"))
      fmt.Println(strings.HasSuffix(ss, "Shark"))
      

      Output

      true true

      Você usaria a função strings.Contains para verificar se "Sammy Shark"contém a sequência Sh:

      fmt.Println(strings.Contains(ss, "Sh"))
      

      Output

      true

      Por fim, para ver quantas vezes a letra S aparece na frase Sammy Shark:

      fmt.Println(strings.Count(ss, "S"))
      

      Output

      2

      Nota: todas as strings em Go diferenciam maiúsculas de minúsculas. Isso significa que Sammy não é o mesmo que sammy.

      Usar um s minúsculo para obter uma contagem do Sammy Shark não é o mesmo que usar o S maiúsculo:

      fmt.Println(strings.Count(ss, "s"))
      

      Output

      0

      Como S é diferente de s, a contagem será 0.

      As funções de string são úteis quando você quer comparar ou pesquisar strings no seu programa.

      Determinando o tamanho da string

      A função integrada len() retorna o número de caracteres em uma string. Essa função é útil para quando você tiver que impor o tamanho mínimo ou máximo de uma senha, por exemplo, ou para truncar strings maiores para que fiquem dentro de certos limites para usar como abreviações.

      Para demonstrar essa função, encontraremos o tamanho de uma string longa:

      import (
          "fmt"
          "strings"
      )
      
      func main() {
              openSource := "Sammy contributes to open source."
              fmt.Println(len(openSource))
      }
      

      Output

      33

      Definimos a variável openSource igual a string "Sammy contributes to open source." e então passamos essa variável para a função len() com len(openSource). Por fim, movemos a função para que faça parte da função fmt.Println() para que pudéssemos ver o resultado do programa na tela.

      Lembre-se de que a função len() contará qualquer caractere vinculado por aspas duplas – incluindo letras, números, espaços em branco e símbolos.

      Funções para a manipulação de string

      As funções strings.Join, strings.Split e strings.ReplaceAll são algumas maneiras adicionais de manipular as strings em Go.

      A função strings.Join é útil para combinar uma fração das strings em uma única e nova string.

      Para criar uma string separada por vírgulas de uma fatia de strings, usaríamos essa função de acordo com o seguinte:

      fmt.Println(strings.Join([]string{"sharks", "crustaceans", "plankton"}, ","))
      

      Output

      sharks,crustaceans,plankton

      Se quisermos adicionar uma vírgula e um espaço entre os valores da string na nossa nova string, podemos simplesmente reescrever nossa expressão com um espaço em branco após a vírgula: strings.Join([]string{"sharks", "crustaceans", "plankton"}, ", ").

      Assim como podemos juntar strings, também podemos dividir as strings. Para fazer isso, podemos usar a função strings.Split e dividir nos espaços:

      balloon := "Sammy has a balloon."
      s := strings.Split(balloon, " ")
      fmt.Println(s)
      

      Output

      [Sammy has a balloon]

      O resultado é uma fatia de strings. Como a função strings.Println foi usada, é difícil distinguir o que seja o resultando apenas olhando para ele. Para verificar que se trata, de fato, de strings, utilize a função fmt.Printf com o verbo %q para citar as strings:

      fmt.Printf("%q", s)
      

      Output

      ["Sammy" "has" "a" "balloon."]

      Outra função útil, além de strings.Split é a strings.Fields. A diferença é que a função strings.Fields irá ignorar todos os espaços em branco e irá dividir apenas os fields em questão em uma string:

      data := "  username password     email  date"
      fields := strings.Fields(data)
      fmt.Printf("%q", fields)
      

      Output

      ["username" "password" "email" "date"]

      A função strings.ReplaceAll pode tomar uma string original e retornar uma string atualizada com algumas substituições.

      Digamos que o balão de Sammy esteja perdido. Como Sammy já não tem esse balão, mudaríamos a substring "has"(tem) da string original balloon (balão) para "had" (tinha) em uma nova string:

      fmt.Println(strings.ReplaceAll(balloon, "has", "had"))
      

      Dentro dos parênteses, primeiro está a variável balloon que armazena a string original; a segunda substring "has" é a que gostaríamos de substituir e a terceira substring "had" é o que iria substituir a segunda substring. Nosso resultado ficaria parecida com a seguinte, depois que incorporarmos isto em um um programa:

      Output

      Sammy had a balloon.

      Usar as funções string strings.Join, strings.Split e strings.ReplaceAll fornecerá a você um maior controle para manipular strings em Go.

      Conclusão

      Este tutorial examinou algumas das funções comuns do pacote string quanto ao tipo de dados de string que você pode usar para trabalhar e manipular strings em seus programas em Go.

      Você pode aprender mais sobre outros tipos de dados em Entendendo os tipos de dados e ler mais sobre strings em Uma introdução para trabalhar com strings.



      Source link