Solicitar um certificado e conferir os certificados emitidos

Neste tópico, descrevemos como solicitar um certificado do Certificate Authority Service e ver os certificados emitidos.

Antes de começar

Verifique se você tem o papel do IAM de Solicitante de certificado de serviço de CA (roles/privateca.certificateRequester) ou de Gerenciador de certificados de serviço de CA (roles/privateca.certificateManager). Para mais informações sobre os papéis de IAM predefinidos para o serviço de CA, consulte Controle de acesso com o IAM.

Para informações sobre como conceder um papel do IAM a um principal, consulte Conceder um único papel.

Visão geral

É possível solicitar um certificado usando os seguintes métodos:

  1. Gere sua própria chave privada ou pública e envie uma solicitação de assinatura de certificado (CSR, na sigla em inglês).
  2. Peça para o serviço de CA criar uma chave privada ou pública para você.
  3. Usar uma chave atual do Cloud Key Management Service (Cloud KMS).

Solicitar certificado usando uma CSR

Antes de continuar, você precisa gerar uma CSR. Depois de gerar uma CSR, faça o seguinte:

Console

  1. Acesse a página Certificate Authority Service no console do Google Cloud.

    Acessar o Certificate Authority Service (em inglês)

  2. Clique na guia CA Manager.

  3. Clique no nome da CA da qual você quer emitir.

  4. Na parte de baixo da página de detalhes da CA, clique em Solicitar um certificado.

  5. Opcional: se você quiser usar um modelo de certificado, clique em , selecione um modelo na lista e clique em Salvar.

  6. Clique em Fornecer CSR.

  7. Opcional: para substituir o nome do certificado gerado automaticamente, insira o nome personalizado no campo Nome do certificado.

  8. Opcional: para escolher um período de validade personalizado para o certificado, insira o valor no campo Válido para.

  9. Copie e cole a CSR na caixa Certificate CSR. Para fazer upload da CSR, clique em Procurar.

  10. Clique em Próxima.

Fazer o download do certificado assinado

  1. Para copiar o certificado, clique em . Para fazer o download do certificado na forma de um arquivo .crt, clique em Fazer o download do certificado.
  2. Opcional: para fazer o download da cadeia de certificados, clique em Fazer o download da cadeia de certificados.
  3. Clique em Concluído.

gcloud

gcloud privateca certificates create CERT_ID \
     --issuer-pool POOL_ID \
     --csr CSR_FILENAME \
     --cert-output-file CERT_FILENAME \
     --validity "P30D"

Substitua:

  • CERT_ID: o identificador exclusivo do certificado.
  • POOL_ID: o nome do pool de ACs.
  • CSR_FILENAME: o arquivo que armazena a CSR codificada em PEM.

A sinalização --validity define o período de validade do certificado. Trata-se de uma sinalização opcional cujo valor padrão é 30 dias.

Para mais informações sobre o comando gcloud privateca certificates create, consulte gcloud privatecacertificate create.

Terraform

resource "google_privateca_certificate_authority" "test_ca" {
  pool                     = "my-pool"
  certificate_authority_id = "my-certificate-authority"
  location                 = "us-central1"
  deletion_protection      = false # set to true to prevent destruction of the resource
  config {
    subject_config {
      subject {
        organization = "HashiCorp"
        common_name  = "my-certificate-authority"
      }
      subject_alt_name {
        dns_names = ["hashicorp.com"]
      }
    }
    x509_config {
      ca_options {
        # is_ca *MUST* be true for certificate authorities
        is_ca = true
      }
      key_usage {
        base_key_usage {
          # cert_sign and crl_sign *MUST* be true for certificate authorities
          cert_sign = true
          crl_sign  = true
        }
        extended_key_usage {
          server_auth = false
        }
      }
    }
  }
  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
}

resource "google_privateca_certificate" "default" {
  pool                  = "my-pool"
  location              = "us-central1"
  certificate_authority = google_privateca_certificate_authority.test_ca.certificate_authority_id
  lifetime              = "860s"
  name                  = "my-certificate"
  pem_csr               = tls_cert_request.example.cert_request_pem
}

resource "tls_private_key" "example" {
  algorithm = "RSA"
}

resource "tls_cert_request" "example" {
  private_key_pem = tls_private_key.example.private_key_pem

  subject {
    common_name  = "example.com"
    organization = "ACME Examples, Inc"
  }
}

API REST

  1. Gere uma solicitação de assinatura de certificado (CSR, na sigla em inglês) usando seu método preferido, como openssl.

    Veja a seguir um exemplo de CSR codificado para JSON.

    -----BEGIN CERTIFICATE REQUEST-----\nMIIChTCCAW0CAQAwQDELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQ8wDQYDVQQK\nDAZKb29uaXgxEzARBgNVBAMMCmpvb25peC5uZXQwggEiMA0GCSqGSIb3DQEBAQUA\nA4IBDwAwggEKAoIBAQCnyy+5vcRQUBPqAse3ojmWjyUvhcJK6eLRXpp0teEUF5kg\nHb2ov8gYXb9sSim5fnvs09dGYDKibSrL4Siy7lA/NzMzWtKwyQQeLIQq/cLUJVcd\ndItJ0VRcqr+UPkTCii2vrdcocNDChHM1J8chDdl6DkpYieSTqZwlPcWlQBGAINmT\nT3Q0ZarIVM5l74j13WPuToGrhbVOIZXWxWqJjlHbBA8B/VKtSRCzM1qG60y8Pu2f\n6c78Dfg8+CGRzGwnz8aFS0Yf9czT9luNHSadS/RHjvE9FPZCsinz+6mJlXRcphi1\nKaHsDbstUAhse1h5E9Biyr9SFYRHxY7qRv9aSJ/dAgMBAAGgADANBgkqhkiG9w0B\nAQsFAAOCAQEAZz+I9ff1Rf3lTewXRUpA7nr5HVO1ojCR93Pf27tI/hvNH7z7GwnS\noScoJlClxeRqABOCnfmVoRChullb/KmER4BZ/lF0GQpEtbqbjgjkEDpVlBKCb0+L\nHE9psplIz6H9nfFS3Ouoiodk902vrMEh0LyDYNQuqFoyCZuuepUlK3NmtmkexlgT\n0pJg/5FV0iaQ+GiFXSZhTC3drfiM/wDnXGiqpbW9WmebSij5O+3BNYXKBUgqmT3r\nbryFydNq4qSOIbnN/MNb4UoKno3ve7mnGk9lIDf9UMPvhl+bT7C3OLQLGadJroME\npYnKLoZUvRwEdtZpbNL9QhCAm2QiJ6w+6g==\n-----END CERTIFICATE REQUEST-----
    
  2. Solicitar um certificado.

    Método HTTP e URL:

    POST https://privateca.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/caPools/POOL_ID/certificates?certificate_id=CERTIFICATE_ID

    Corpo JSON da solicitação:

    {
     "lifetime": {
       "seconds": 3600,
       "nanos": 0
     },
     "pem_csr": "PEM_CSR"
    }
    

    Para enviar a solicitação, expanda uma destas opções:

    Você receberá uma resposta JSON semelhante a esta:

    {
     "name": "projects/project-id/locations/location/certificateAuthorities/ca-id/certificates/certificate-id",
     "pemCertificate": "-----BEGIN CERTIFICATE-----...",
     "certificateDescription": {...}
    }
    

Solicitar certificado usando uma chave gerada automaticamente

Console

É possível usar o console do Google Cloud para gerar certificados TLS de cliente ou servidor.

  1. No console do Google Cloud, acesse a página Certificate Authority Service.

    Acessar o Certificate Authority Service (em inglês)

  2. Clique na guia CA Manager.

  3. Clique no nome da CA da qual você quer emitir.

  4. Na parte inferior da página de detalhes Autoridade de certificação, clique em Solicitar um certificado.

  5. Opcional: se você quiser usar um modelo de certificado, clique em , selecione um modelo na lista e clique em Salvar.

  6. Clique em Inserir detalhes.

  7. Opcional: substitua o Nome do certificado gerado automaticamente por um nome personalizado exclusivo.

  8. Opcional: para escolher um período de validade personalizado para o certificado, insira o valor no campo Válido para.

Adicionar nome de domínio

  1. Em Adicionar nome de domínio, digite um nome de domínio no campo Nome de domínio 1.
  2. Opcional: para adicionar mais de um nome de domínio, clique em Adicionar item e digite outro nome de domínio no campo Nome de domínio 2.

Uso estendido de chave

  1. Opcional: em Uso estendido de chave, selecione uma das opções a seguir com base no seu caso de uso:

    • TLS do servidor: esses certificados permitem autenticar a identidade de um servidor.
    • TLS do cliente: esses certificados permitem autenticar a identidade de um solicitante.
  2. Clique em Próxima.

Configurar o tamanho e o algoritmo da chave

  1. Opcional: em Configurar o tamanho e o algoritmo da chave, selecione o tamanho e o algoritmo da chave de assinatura na lista. Se você pular essa etapa, será usada a chave RSASSA-PSS de 2.048 bits com um resumo SHA 256. Para saber mais sobre como selecionar uma chave de assinatura e um algoritmo, consulte Escolher um algoritmo de chave.
  2. Clique em Continuar.

Fazer o download do certificado assinado

  1. Opcional: para fazer o download da cadeia de certificados codificadas em PEM, clique em Fazer o download da cadeia de certificados.
  2. Opcional: para fazer o download da chave privada codificada em PEM associada, clique em Fazer o download da chave privada.

  3. Clique em Concluído.

gcloud

Para usar o recurso de chave gerada automaticamente, instale a biblioteca Python Cryptographic Authority (PyCA). Para instruções sobre como instalar a biblioteca de criptografia Pyca, consulte Como incluir a biblioteca de criptografia Pyca.

Para criar um certificado, use o seguinte comando gcloud:

gcloud privateca certificates create \
  --issuer-pool POOL_ID \
  --generate-key \
  --key-output-file KEY_FILENAME \
  --cert-output-file CERT_FILENAME \
  --dns-san "DNS_NAME" \
  --use-preset-profile "CERTIFICATE_PROFILE"

Substitua:

  • POOL_ID: o nome do pool de ACs.
  • KEY_FILENAME: o caminho em que o arquivo de chave privada gerado precisa ser gravado.
  • CERT_FILENAME: o caminho em que o arquivo de cadeia de certificados codificado em PEM precisa ser gravado. A cadeia de certificados é ordenada da entidade final para a raiz.
  • DNS_NAME: um ou mais nomes alternativos do assunto DNS (SANs, na sigla em inglês) separados por vírgulas.
  • CERTIFICATE_PROFILE: o identificador exclusivo do perfil de certificado. Por exemplo, use leaf_server_tls para o TLS do servidor da entidade final.

O comando gcloud menciona as seguintes sinalizações:

  • --generate-key: gera uma nova chave privada RSA-2048 na sua máquina.

Também é possível usar qualquer combinação das seguintes sinalizações:

  • --dns-san: permite transmitir um ou mais SANs DNS separadas por vírgulas.
  • --ip-san: permite transmitir um ou mais SANs IP separados por vírgulas.
  • --uri-san: permite transmitir um ou mais SANs de URI separados por vírgulas.
  • --subject: permite transmitir um nome X.501 do assunto do certificado.

Para mais informações sobre o comando gcloud privateca certificates create, consulte gcloud privatecacertificate create.

Go

Para autenticar no serviço de CA, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

import (
	"context"
	"fmt"
	"io"

	privateca "cloud.google.com/go/security/privateca/apiv1"
	"cloud.google.com/go/security/privateca/apiv1/privatecapb"
	"google.golang.org/protobuf/types/known/durationpb"
)

// Create a Certificate which is issued by the Certificate Authority present in the CA Pool.
// The key used to sign the certificate is created by the Cloud KMS.
func createCertificate(
	w io.Writer,
	projectId string,
	location string,
	caPoolId string,
	caId string,
	certId string,
	commonName string,
	domainName string,
	certDuration int64,
	publicKeyBytes []byte) error {
	// projectId := "your_project_id"
	// location := "us-central1"		// For a list of locations, see: https://cloud.google.com/certificate-authority-service/docs/locations.
	// caPoolId := "ca-pool-id"			// The CA Pool id in which the certificate authority exists.
	// caId := "ca-id"					// The name of the certificate authority which issues the certificate.
	// certId := "certificate"			// A unique name for the certificate.
	// commonName := "cert-name"		// A common name for the certificate.
	// domainName := "cert.example.com"	// Fully qualified domain name for the certificate.
	// certDuration := int64(31536000)	// The validity of the certificate in seconds.
	// publicKeyBytes 					// The public key used in signing the certificates.

	ctx := context.Background()
	caClient, err := privateca.NewCertificateAuthorityClient(ctx)
	if err != nil {
		return fmt.Errorf("NewCertificateAuthorityClient creation failed: %w", err)
	}
	defer caClient.Close()

	// Set the Public Key and its format.
	publicKey := &privatecapb.PublicKey{
		Key:    publicKeyBytes,
		Format: privatecapb.PublicKey_PEM,
	}

	// Set Certificate subject config.
	subjectConfig := &privatecapb.CertificateConfig_SubjectConfig{
		Subject: &privatecapb.Subject{
			CommonName: commonName,
		},
		SubjectAltName: &privatecapb.SubjectAltNames{
			DnsNames: []string{domainName},
		},
	}

	// Set the X.509 fields required for the certificate.
	x509Parameters := &privatecapb.X509Parameters{
		KeyUsage: &privatecapb.KeyUsage{
			BaseKeyUsage: &privatecapb.KeyUsage_KeyUsageOptions{
				DigitalSignature: true,
				KeyEncipherment:  true,
			},
			ExtendedKeyUsage: &privatecapb.KeyUsage_ExtendedKeyUsageOptions{
				ServerAuth: true,
				ClientAuth: true,
			},
		},
	}

	// Set certificate settings.
	cert := &privatecapb.Certificate{
		CertificateConfig: &privatecapb.Certificate_Config{
			Config: &privatecapb.CertificateConfig{
				PublicKey:     publicKey,
				SubjectConfig: subjectConfig,
				X509Config:    x509Parameters,
			},
		},
		Lifetime: &durationpb.Duration{
			Seconds: certDuration,
		},
	}

	fullCaPoolName := fmt.Sprintf("projects/%s/locations/%s/caPools/%s", projectId, location, caPoolId)

	// Create the CreateCertificateRequest.
	// See https://pkg.go.dev/cloud.google.com/go/security/privateca/apiv1/privatecapb#CreateCertificateRequest.
	req := &privatecapb.CreateCertificateRequest{
		Parent:                        fullCaPoolName,
		CertificateId:                 certId,
		Certificate:                   cert,
		IssuingCertificateAuthorityId: caId,
	}

	_, err = caClient.CreateCertificate(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateCertificate failed: %w", err)
	}

	fmt.Fprintf(w, "Certificate %s created", certId)

	return nil
}

Java

Para autenticar no serviço de CA, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.


import com.google.api.core.ApiFuture;
import com.google.cloud.security.privateca.v1.CaPoolName;
import com.google.cloud.security.privateca.v1.Certificate;
import com.google.cloud.security.privateca.v1.CertificateAuthorityServiceClient;
import com.google.cloud.security.privateca.v1.CertificateConfig;
import com.google.cloud.security.privateca.v1.CertificateConfig.SubjectConfig;
import com.google.cloud.security.privateca.v1.CreateCertificateRequest;
import com.google.cloud.security.privateca.v1.KeyUsage;
import com.google.cloud.security.privateca.v1.KeyUsage.ExtendedKeyUsageOptions;
import com.google.cloud.security.privateca.v1.KeyUsage.KeyUsageOptions;
import com.google.cloud.security.privateca.v1.PublicKey;
import com.google.cloud.security.privateca.v1.PublicKey.KeyFormat;
import com.google.cloud.security.privateca.v1.Subject;
import com.google.cloud.security.privateca.v1.SubjectAltNames;
import com.google.cloud.security.privateca.v1.X509Parameters;
import com.google.cloud.security.privateca.v1.X509Parameters.CaOptions;
import com.google.protobuf.ByteString;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class CreateCertificate {

  public static void main(String[] args)
      throws InterruptedException, ExecutionException, IOException {
    // TODO(developer): Replace these variables before running the sample.

    // publicKeyBytes: Public key used in signing the certificates.
    // location: For a list of locations, see:
    // https://cloud.google.com/certificate-authority-service/docs/locations
    // poolId: Set a unique id for the CA pool.
    // certificateAuthorityName: The name of the certificate authority which issues the certificate.
    // certificateName: Set a unique name for the certificate.
    String project = "your-project-id";
    ByteString publicKeyBytes = ByteString.copyFrom(new byte[]{});
    String location = "ca-location";
    String poolId = "ca-poolId";
    String certificateAuthorityName = "certificate-authority-name";
    String certificateName = "certificate-name";

    createCertificate(
        project, location, poolId, certificateAuthorityName, certificateName, publicKeyBytes);
  }

  // Create a Certificate which is issued by the Certificate Authority present in the CA Pool.
  // The public key used to sign the certificate can be generated using any crypto
  // library/framework.
  public static void createCertificate(
      String project,
      String location,
      String poolId,
      String certificateAuthorityName,
      String certificateName,
      ByteString publicKeyBytes)
      throws InterruptedException, ExecutionException, IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `certificateAuthorityServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (CertificateAuthorityServiceClient certificateAuthorityServiceClient =
        CertificateAuthorityServiceClient.create()) {

      // commonName: Enter a title for your certificate.
      // orgName: Provide the name of your company.
      // domainName: List the fully qualified domain name.
      // certificateLifetime: The validity of the certificate in seconds.
      String commonName = "commonname";
      String orgName = "orgname";
      String domainName = "dns.example.com";
      long certificateLifetime = 1000L;

      // Set the Public Key and its format.
      PublicKey publicKey =
          PublicKey.newBuilder().setKey(publicKeyBytes).setFormat(KeyFormat.PEM).build();

      SubjectConfig subjectConfig =
          SubjectConfig.newBuilder()
              // Set the common name and org name.
              .setSubject(
                  Subject.newBuilder().setCommonName(commonName).setOrganization(orgName).build())
              // Set the fully qualified domain name.
              .setSubjectAltName(SubjectAltNames.newBuilder().addDnsNames(domainName).build())
              .build();

      // Set the X.509 fields required for the certificate.
      X509Parameters x509Parameters =
          X509Parameters.newBuilder()
              .setKeyUsage(
                  KeyUsage.newBuilder()
                      .setBaseKeyUsage(
                          KeyUsageOptions.newBuilder()
                              .setDigitalSignature(true)
                              .setKeyEncipherment(true)
                              .setCertSign(true)
                              .build())
                      .setExtendedKeyUsage(
                          ExtendedKeyUsageOptions.newBuilder().setServerAuth(true).build())
                      .build())
              .setCaOptions(CaOptions.newBuilder().setIsCa(true).buildPartial())
              .build();

      // Create certificate.
      Certificate certificate =
          Certificate.newBuilder()
              .setConfig(
                  CertificateConfig.newBuilder()
                      .setPublicKey(publicKey)
                      .setSubjectConfig(subjectConfig)
                      .setX509Config(x509Parameters)
                      .build())
              .setLifetime(Duration.newBuilder().setSeconds(certificateLifetime).build())
              .build();

      // Create the Certificate Request.
      CreateCertificateRequest certificateRequest =
          CreateCertificateRequest.newBuilder()
              .setParent(CaPoolName.of(project, location, poolId).toString())
              .setCertificateId(certificateName)
              .setCertificate(certificate)
              .setIssuingCertificateAuthorityId(certificateAuthorityName)
              .build();

      // Get the Certificate response.
      ApiFuture<Certificate> future =
          certificateAuthorityServiceClient
              .createCertificateCallable()
              .futureCall(certificateRequest);

      Certificate response = future.get();
      // Get the PEM encoded, signed X.509 certificate.
      System.out.println(response.getPemCertificate());
      // To verify the obtained certificate, use this intermediate chain list.
      System.out.println(response.getPemCertificateChainList());
    }
  }
}

Python

Para autenticar no serviço de CA, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

import google.cloud.security.privateca_v1 as privateca_v1
from google.protobuf import duration_pb2

def create_certificate(
    project_id: str,
    location: str,
    ca_pool_name: str,
    ca_name: str,
    certificate_name: str,
    common_name: str,
    domain_name: str,
    certificate_lifetime: int,
    public_key_bytes: bytes,
) -> None:
    """
    Create a Certificate which is issued by the Certificate Authority present in the CA Pool.
    The key used to sign the certificate is created by the Cloud KMS.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        location: location you want to use. For a list of locations, see: https://cloud.google.com/certificate-authority-service/docs/locations.
        ca_pool_name: set a unique name for the CA pool.
        ca_name: the name of the certificate authority which issues the certificate.
        certificate_name: set a unique name for the certificate.
        common_name: a title for your certificate.
        domain_name: fully qualified domain name for your certificate.
        certificate_lifetime: the validity of the certificate in seconds.
        public_key_bytes: public key used in signing the certificates.
    """

    caServiceClient = privateca_v1.CertificateAuthorityServiceClient()

    # The public key used to sign the certificate can be generated using any crypto library/framework.
    # Also you can use Cloud KMS to retrieve an already created public key.
    # For more info, see: https://cloud.google.com/kms/docs/retrieve-public-key.

    # Set the Public Key and its format.
    public_key = privateca_v1.PublicKey(
        key=public_key_bytes,
        format_=privateca_v1.PublicKey.KeyFormat.PEM,
    )

    subject_config = privateca_v1.CertificateConfig.SubjectConfig(
        subject=privateca_v1.Subject(common_name=common_name),
        subject_alt_name=privateca_v1.SubjectAltNames(dns_names=[domain_name]),
    )

    # Set the X.509 fields required for the certificate.
    x509_parameters = privateca_v1.X509Parameters(
        key_usage=privateca_v1.KeyUsage(
            base_key_usage=privateca_v1.KeyUsage.KeyUsageOptions(
                digital_signature=True,
                key_encipherment=True,
            ),
            extended_key_usage=privateca_v1.KeyUsage.ExtendedKeyUsageOptions(
                server_auth=True,
                client_auth=True,
            ),
        ),
    )

    # Create certificate.
    certificate = privateca_v1.Certificate(
        config=privateca_v1.CertificateConfig(
            public_key=public_key,
            subject_config=subject_config,
            x509_config=x509_parameters,
        ),
        lifetime=duration_pb2.Duration(seconds=certificate_lifetime),
    )

    # Create the Certificate Request.
    request = privateca_v1.CreateCertificateRequest(
        parent=caServiceClient.ca_pool_path(project_id, location, ca_pool_name),
        certificate_id=certificate_name,
        certificate=certificate,
        issuing_certificate_authority_id=ca_name,
    )
    result = caServiceClient.create_certificate(request=request)

    print("Certificate creation result:", result)

Solicitar certificado usando uma chave do Cloud KMS

Para usar uma chave do Cloud KMS a fim de criar um certificado TLS do servidor de entidade final, execute o seguinte comando:

gcloud privateca certificates create \
  --issuer-pool POOL_ID \
  --kms-key-version projects/PROJECT_ID/locations/LOCATION_ID/keyRings/KEY_RING/cryptoKeys/KEY/cryptoKeyVersions/KEY_VERSION \
  --cert-output-file CERT_FILENAME \
  --dns-san "DNS_NAME" \
  --use-preset-profile "leaf_server_tls"

Substitua:

  • POOL_ID: o nome do pool de ACs.
  • PROJECT_ID: o ID do projeto.
  • LOCATION_ID: a localização do keyring.
  • KEY_RING: o nome do keyring em que a chave está localizada.
  • KEY: o nome da chave.
  • KEY_VERSION: a versão da chave.
  • CERT_FILENAME: o caminho do arquivo de cadeia de certificados codificado em PEM. O arquivo da cadeia de certificados é ordenado da entidade final para a raiz.
  • DNS_NAME: SANs DNS separadas por vírgulas.

Como executar operações comuns com certificados

Nesta seção, descrevemos como executar determinadas operações comuns com certificados.

Emitir um certificado de uma AC específica em um pool de ACs

gcloud

Para segmentar uma AC específica no pool de ACs para a emissão de certificados, adicione a sinalização --ca com o CA_ID da AC que precisa emitir o certificado.

gcloud privateca certificates create \
  --issuer-pool POOL_ID \
  --ca CA_ID \
  --generate-key \
  --key-output-file KEY_FILENAME \
  --cert-output-file CERT_FILENAME \
  --dns-san "DNS_NAME" \
  --use-preset-profile "leaf_server_tls"

Console

O console do Google Cloud só oferece suporte à emissão de certificados por uma determinada CA. Siga as instruções na seção Solicitar certificado usando uma chave gerada automaticamente ou Solicitar certificado usando uma CSR para escolher a CA que precisa emitir o certificado.

Terraform

resource "google_privateca_certificate_authority" "authority" {
  // This example assumes this pool already exists.
  // Pools cannot be deleted in normal test circumstances, so we depend on static pools
  pool                     = "my-pool"
  certificate_authority_id = "my-sample-certificate-authority"
  location                 = "us-central1"
  deletion_protection      = false # set to true to prevent destruction of the resource
  config {
    subject_config {
      subject {
        organization = "HashiCorp"
        common_name  = "my-certificate-authority"
      }
      subject_alt_name {
        dns_names = ["hashicorp.com"]
      }
    }
    x509_config {
      ca_options {
        is_ca = true
      }
      key_usage {
        base_key_usage {
          digital_signature = true
          cert_sign         = true
          crl_sign          = true
        }
        extended_key_usage {
          server_auth = true
        }
      }
    }
  }
  lifetime = "86400s"
  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
}

resource "google_privateca_certificate" "default" {
  pool     = "my-pool"
  location = "us-central1"
  lifetime = "860s"
  name     = "my-sample-certificate"
  config {
    subject_config {
      subject {
        common_name         = "san1.example.com"
        country_code        = "us"
        organization        = "google"
        organizational_unit = "enterprise"
        locality            = "mountain view"
        province            = "california"
        street_address      = "1600 amphitheatre parkway"
        postal_code         = "94109"
      }
    }
    x509_config {
      ca_options {
        is_ca = false
      }
      key_usage {
        base_key_usage {
          crl_sign = true
        }
        extended_key_usage {
          server_auth = true
        }
      }
    }
    public_key {
      format = "PEM"
      key    = base64encode(data.tls_public_key.example.public_key_pem)
    }
  }
  // Certificates require an authority to exist in the pool, though they don't
  // need to be explicitly connected to it
  depends_on = [google_privateca_certificate_authority.authority]
}

resource "tls_private_key" "example" {
  algorithm = "RSA"
}

data "tls_public_key" "example" {
  private_key_pem = tls_private_key.example.private_key_pem
}

Ver certificados emitidos

Console

  1. No console do Google Cloud, acesse a página Certificate Authority Service.

    Acessar o Certificate Authority Service (em inglês)

  2. Clique na guia CA manager.

  3. Na página Autoridades de certificação, clique no nome da CA.

  4. Na parte inferior da página de detalhes Autoridade de certificação, clique em Ver certificados emitidos para ver a lista de certificados emitidos pela CA.

    Os certificados ficam na página Todos os certificados. Os detalhes incluem o status do certificado, a CA emissora, o pool de CAs que contém a CA, a data de validade do certificado e muito mais.

gcloud

Para listar todos os certificados emitidos por uma determinada CA em um pool de CAs, use o seguinte comando gcloud:

gcloud privateca certificates list --issuer-pool ISSUER_POOL --ca CA_NAME

Para mais informações sobre o comando gcloud privateca certificates list, consulte gcloud privatecacertificate list.

Para listar todos os certificados de todas as CAs em um determinado local, use o seguinte comando gcloud:

gcloud privateca certificates list --location LOCATION

Go

Para autenticar no serviço de CA, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

import (
	"context"
	"fmt"
	"io"

	privateca "cloud.google.com/go/security/privateca/apiv1"
	"cloud.google.com/go/security/privateca/apiv1/privatecapb"
	"google.golang.org/api/iterator"
)

// List Certificates present in the given CA pool.
func listCertificates(
	w io.Writer,
	projectId string,
	location string,
	caPoolId string) error {
	// projectId := "your_project_id"
	// location := "us-central1"		// For a list of locations, see: https://cloud.google.com/certificate-authority-service/docs/locations.
	// caPoolId := "ca-pool-id"			// The CA Pool id in which the certificate exists.

	ctx := context.Background()
	caClient, err := privateca.NewCertificateAuthorityClient(ctx)
	if err != nil {
		return fmt.Errorf("NewCertificateAuthorityClient creation failed: %w", err)
	}
	defer caClient.Close()

	fullCaName := fmt.Sprintf("projects/%s/locations/%s/caPools/%s", projectId, location, caPoolId)

	// Create the ListCertificatesRequest.
	// See https://pkg.go.dev/cloud.google.com/go/security/privateca/apiv1/privatecapb#ListCertificatesRequest.
	req := &privatecapb.ListCertificatesRequest{Parent: fullCaName}

	it := caClient.ListCertificates(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("unable to get the list of cerficates: %w", err)
		}

		fmt.Fprintf(w, " - %s (common name: %s)", resp.Name,
			resp.CertificateDescription.SubjectDescription.Subject.CommonName)
	}

	return nil
}

Java

Para autenticar no serviço de CA, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.


import com.google.cloud.security.privateca.v1.CaPoolName;
import com.google.cloud.security.privateca.v1.Certificate;
import com.google.cloud.security.privateca.v1.CertificateAuthorityServiceClient;
import java.io.IOException;

public class ListCertificates {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // location: For a list of locations, see:
    // https://cloud.google.com/certificate-authority-service/docs/locations
    // poolId: Id of the CA pool which contains the certificates to be listed.
    String project = "your-project-id";
    String location = "ca-location";
    String poolId = "ca-pool-id";
    listCertificates(project, location, poolId);
  }

  // List Certificates present in the given CA pool.
  public static void listCertificates(String project, String location, String poolId)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `certificateAuthorityServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (CertificateAuthorityServiceClient certificateAuthorityServiceClient =
        CertificateAuthorityServiceClient.create()) {

      CaPoolName caPool =
          CaPoolName.newBuilder()
              .setProject(project)
              .setLocation(location)
              .setCaPool(poolId)
              .build();

      // Retrieve and print the certificate names.
      System.out.println("Available certificates: ");
      for (Certificate certificate :
          certificateAuthorityServiceClient.listCertificates(caPool).iterateAll()) {
        System.out.println(certificate.getName());
      }
    }
  }
}

Python

Para autenticar no serviço de CA, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.


import google.cloud.security.privateca_v1 as privateca_v1

def list_certificates(
    project_id: str,
    location: str,
    ca_pool_name: str,
) -> None:
    """
    List Certificates present in the given CA pool.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        location: location you want to use. For a list of locations, see: https://cloud.google.com/certificate-authority-service/docs/locations.
        ca_pool_name: name of the CA pool which contains the certificates to be listed.
    """

    caServiceClient = privateca_v1.CertificateAuthorityServiceClient()

    ca_pool_path = caServiceClient.ca_pool_path(project_id, location, ca_pool_name)

    # Retrieve and print the certificate names.
    print(f"Available certificates in CA pool {ca_pool_name}:")
    for certificate in caServiceClient.list_certificates(parent=ca_pool_path):
        print(certificate.name)

Mais detalhes de um único certificado

Console

  1. No console do Google Cloud, acesse a página Certificate Authority Service.

    Acessar o Certificate Authority Service (em inglês)

  2. Escolha a CA desejada na guia CA Manager.

  3. Clique no nome da CA.

  4. Na parte inferior da página de detalhes Autoridade de certificação, clique em Ver certificados emitidos para consultar a lista de certificados emitidos.

  5. Clique em na coluna Ações do certificado que você quer transferir por download.

  6. Em Fazer o download, clique em Certificado. Para fazer o download da cadeia de certificados, clique em Cadeia de certificados.

gcloud

Para ver a descrição completa de um certificado, execute o seguinte comando:

gcloud privateca certificates describe CERT_NAME \
    --issuer-pool POOL_ID

Para mais informações sobre o comando gcloud privateca certificates describe, consulte gcloud privateca Certificates describe.

Para exportar a cadeia de certificados X.509 codificada em PEM e para um arquivo, execute o seguinte comando:

gcloud privateca certificates export CERT_NAME \
    --issuer-pool POOL_ID \
    --include-chain \
    --output-file certificate-file

Para mais informações sobre o comando gcloud privateca certificates export, consulte gcloud privatecacertificate export.

Comprovante de posse de certificados

O comprovante de posse da chave privada garante que o solicitante do certificado tenha essa chave. O CA Service verifica o comprovante de posse somente se o solicitante fornecer um CSR PKCS #10 de acordo com a RFC 2986. A prova de posse para outras formas de solicitações de certificado, como solicitações de CertificateConfig, não é aplicada.

Os aplicativos clientes que aceitam certificados são responsáveis por validar se o titular do certificado tem a chave privada desse certificado. Aplicar verificações de comprovação de posse durante a emissão do certificado é uma forma de defesa profunda para proteger contra clientes que se comportam mal. A existência desses clientes, mesmo que a CA verifique a posse deles, pode constituir uma vulnerabilidade de segurança.

A seguir