Crea una autoridad certificadora subordinada

En esta página, se describe cómo crear autoridades certificadoras (AC) subordinadas en un grupo de AC.

Las AC subordinadas son responsables de emitir certificados directamente a y las entidades finales, como usuarios, computadoras y dispositivos. Las AC subordinadas están firmadas de forma criptográfica por una AC superior, que suele ser la AC raíz. Como resultado, los sistemas que confían en la AC raíz confían automáticamente en las AC subordinadas y en los certificados de entidad final que emiten las AC subordinadas.

Antes de comenzar

• Asegúrate de que cuentas con el Administrador de operaciones del Servicio de CA. (roles/privateca.caManager) o el administrador del servicio de CA (roles/privateca.admin) rol de IAM. Para obtener información, consulta Configura las políticas de IAM.
• Crea un grupo de CA.
• Selecciona tu AC raíz.

Crea una AC subordinada

Las AC subordinadas son más fáciles de revocar y rotar que las AC raíz. Si tienes varias situaciones de emisión de certificados, puedes crear una AC subordinada para cada una. Agregar varias AC subordinadas en un grupo de AC te ayuda a lograr un mejor balanceo de cargas de solicitudes de certificado y un QPS total efectivo más alto.

Para crear una AC subordinada, haz lo siguiente:

Console

1. Ve a la página Certificate Authority Service en la consola de Google Cloud.

   Ir a Certificate Authority Service

2. Haz clic en la pestaña Administrador de AC.

3. Haz clic en Crear AC.

   

Selecciona el tipo de AC

1. Haz clic en CA subordinada.
2. Haz clic en La AC raíz está en Google Cloud.
3. En el campo Se aplica a, ingresa la duración que desees. que el certificado de la AC sea válido.
4. Opcional: Elige el nivel de la AC. El nivel predeterminado es Empresarial. Para obtener más información, consulta Selecciona los niveles de operación.
5. Haz clic en Región para seleccionar una ubicación para la AC. Para obtener más información, consulta Ubicaciones.
6. Opcional: En Estado inicializado, selecciona el estado en el que debe estar la AC en el momento de la creación.
7. Opcional: En Configura una situación de emisión, haz clic en Perfil de certificado y selecciona el perfil de certificado que que mejor se adapte a tus requisitos de la lista. Para ver más consulta Perfiles de certificados.
8. Haz clic en Siguiente.

Configurar el nombre del asunto de CA

1. En el campo Organización (O), ingresa el nombre de tu empresa.
2. Opcional: En el campo Unidad organizativa (UO), ingresa la empresa. subdivisión o unidad de negocios.
3. Opcional: En el campo Nombre del país, ingresa un código de país de dos letras.
4. Opcional: En el campo Nombre del estado o provincia, ingresa el nombre de tu estado.
5. Opcional: En el campo Nombre de la localidad, ingresa el nombre de tu ciudad.
6. En el campo Nombre común de AC (CN), ingresa el nombre de la AC.
7. En el campo ID de grupo, ingresa el nombre del grupo de AC. No puedes cambiar el pool de AC después de crearla.
8. Haz clic en Siguiente.

Cómo configurar el algoritmo y el tamaño de la clave de AC

1. Elige el algoritmo clave que mejor se adapte a tus necesidades. Para obtener información sobre cómo decidir el algoritmo de clave adecuado, consulta Elige un algoritmo de clave.
2. Haz clic en Siguiente.

Configura artefactos de CA

Los siguientes pasos son opcionales. Si omites estos pasos, se aplicará la configuración predeterminada.

1. Elige si quieres usar una cuenta administrada por Google bucket de Cloud Storage.

Si no seleccionas un bucket autoadministrado de Cloud Storage, CA Service crea un bucket administrado por Google en el mismo que la AC.

2. Elige si quieres inhabilitar la publicación de las listas de revocación de certificados (CRL) y los certificados de AC en el bucket de Cloud Storage.

La publicación de la CRL y el certificado de AC en un bucket de Cloud Storage está habilitada de forma predeterminada. Para inhabilitar esta configuración, haz clic en los botones de activación.

3. Haz clic en Siguiente.

Agrega etiquetas

Los siguientes pasos son opcionales.

Si deseas agregar etiquetas a la AC, haz lo siguiente:

1. Haz clic en Agregar elemento.
2. En el campo Clave 1, ingresa la clave de etiqueta.
3. En el campo Valor 1, ingresa el valor de la etiqueta.
4. Si deseas agregar otra etiqueta, haz clic en Agregar elemento. Luego, agrega la clave y el valor de la etiqueta como se menciona en los pasos 2 y 3.
5. Haz clic en Siguiente.

Revisar la configuración

Revisa cuidadosamente todos los parámetros de configuración y, luego, haz clic en Crear para crear la AC.

gcloud

1. Crea un grupo de AC para la AC subordinada:

   gcloud privateca pools create SUBORDINATE_POOL_ID
   

   Reemplaza SUBORDINATE_POOL_ID por el nombre del grupo de AC.

   Para obtener más información sobre cómo crear grupos de AC, consulta Cómo crear un grupo de AC.

   Para obtener más información sobre el comando gcloud privateca pools create, consulta gcloud privateca pools create.

2. Crea una AC subordinada en el grupo de AC creado.

   Nota: Puedes obtener el ID de recurso del emisor (POOL_ID) copiando el ID del comando create o aprovechando el comando gcloud privateca pools list.

   gcloud privateca subordinates create SUBORDINATE_CA_ID \
     --pool=SUBORDINATE_POOL_ID \
     --issuer-pool=POOL_ID \
     --key-algorithm="ec-p256-sha256" \
     --subject="CN=Example Server TLS CA, O=Example LLC"
   

   Se muestra la siguiente sentencia cuando se crea la AC subordinada.

   Created Certificate Authority [projects/my-project-pki/locations/us-west1/caPools/SUBORDINATE_POOL_ID/certificateAuthorities/SUBORDINATE_CA_ID].
   

   Para ver una lista completa de las opciones de configuración, ejecuta el siguiente comando gcloud:

   gcloud privateca subordinates create --help
   

   El comando muestra ejemplos para crear una AC subordinada cuyo emisor se encuentra en el servicio de AC o en otro lugar.

Terraform

resource "google_privateca_certificate_authority" "root_ca" {
  pool                                   = "my-pool"
  certificate_authority_id               = "my-certificate-authority-root"
  location                               = "us-central1"
  deletion_protection                    = false # set to true to prevent destruction of the resource
  ignore_active_certificates_on_deletion = true
  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_authority" "default" {
  // 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-certificate-authority-sub"
  location                 = "us-central1"
  deletion_protection      = false # set to true to prevent destruction of the resource
  subordinate_config {
    certificate_authority = google_privateca_certificate_authority.root_ca.name
  }
  config {
    subject_config {
      subject {
        organization = "HashiCorp"
        common_name  = "my-subordinate-authority"
      }
      subject_alt_name {
        dns_names = ["hashicorp.com"]
      }
    }
    x509_config {
      ca_options {
        is_ca = true
        # Force the sub CA to only issue leaf certs
        max_issuer_path_length = 0
      }
      key_usage {
        base_key_usage {
          digital_signature  = true
          content_commitment = true
          key_encipherment   = false
          data_encipherment  = true
          key_agreement      = true
          cert_sign          = true
          crl_sign           = true
          decipher_only      = true
        }
        extended_key_usage {
          server_auth      = true
          client_auth      = false
          email_protection = true
          code_signing     = true
          time_stamping    = true
        }
      }
    }
  }
  lifetime = "86400s"
  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
  type = "SUBORDINATE"
}

Java

Para autenticarte en el servicio de AC, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

import com.google.api.core.ApiFuture;
import com.google.cloud.security.privateca.v1.CaPoolName;
import com.google.cloud.security.privateca.v1.CertificateAuthority;
import com.google.cloud.security.privateca.v1.CertificateAuthority.KeyVersionSpec;
import com.google.cloud.security.privateca.v1.CertificateAuthority.SignHashAlgorithm;
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.CreateCertificateAuthorityRequest;
import com.google.cloud.security.privateca.v1.KeyUsage;
import com.google.cloud.security.privateca.v1.KeyUsage.KeyUsageOptions;
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.longrunning.Operation;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class CreateSubordinateCa {

  public static void main(String[] args)
      throws InterruptedException, ExecutionException, 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: Set it to the CA Pool under which the CA should be created.
    // subordinateCaName: Unique name for the Subordinate CA.
    String project = "your-project-id";
    String location = "ca-location";
    String poolId = "ca-pool-id";
    String subordinateCaName = "subordinate-certificate-authority-name";

    createSubordinateCertificateAuthority(project, location, poolId, subordinateCaName);
  }

  public static void createSubordinateCertificateAuthority(
      String project, String location, String poolId, String subordinateCaName)
      throws IOException, ExecutionException, InterruptedException {
    // 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()) {

      String commonName = "commonname";
      String orgName = "csr-org-name";
      String domainName = "dns.example.com";
      int caDuration = 100000; // Validity of this CA in seconds.

      // Set the type of Algorithm.
      KeyVersionSpec keyVersionSpec =
          KeyVersionSpec.newBuilder().setAlgorithm(SignHashAlgorithm.RSA_PKCS1_4096_SHA256).build();

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

      //  Set the key usage options for X.509 fields.
      X509Parameters x509Parameters =
          X509Parameters.newBuilder()
              .setKeyUsage(
                  KeyUsage.newBuilder()
                      .setBaseKeyUsage(
                          KeyUsageOptions.newBuilder().setCrlSign(true).setCertSign(true).build())
                      .build())
              .setCaOptions(CaOptions.newBuilder().setIsCa(true).build())
              .build();

      // Set certificate authority settings.
      CertificateAuthority subCertificateAuthority =
          CertificateAuthority.newBuilder()
              .setType(CertificateAuthority.Type.SUBORDINATE)
              .setKeySpec(keyVersionSpec)
              .setConfig(
                  CertificateConfig.newBuilder()
                      .setSubjectConfig(subjectConfig)
                      .setX509Config(x509Parameters)
                      .build())
              // Set the CA validity duration.
              .setLifetime(Duration.newBuilder().setSeconds(caDuration).build())
              .build();

      // Create the CertificateAuthorityRequest.
      CreateCertificateAuthorityRequest subCertificateAuthorityRequest =
          CreateCertificateAuthorityRequest.newBuilder()
              .setParent(CaPoolName.of(project, location, poolId).toString())
              .setCertificateAuthorityId(subordinateCaName)
              .setCertificateAuthority(subCertificateAuthority)
              .build();

      // Create Subordinate CA.
      ApiFuture<Operation> futureCall =
          certificateAuthorityServiceClient
              .createCertificateAuthorityCallable()
              .futureCall(subCertificateAuthorityRequest);

      Operation response = futureCall.get();

      if (response.hasError()) {
        System.out.println("Error while creating Subordinate CA !" + response.getError());
        return;
      }

      System.out.println(
          "Subordinate Certificate Authority created successfully : " + subordinateCaName);
    }
  }
}

Python

Para autenticarte en el servicio de AC, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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


def create_subordinate_ca(
    project_id: str,
    location: str,
    ca_pool_name: str,
    subordinate_ca_name: str,
    common_name: str,
    organization: str,
    domain: str,
    ca_duration: int,
) -> None:
    """
    Create Certificate Authority (CA) which is the subordinate CA 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: set it to the CA Pool under which the CA should be created.
        subordinate_ca_name: unique name for the Subordinate CA.
        common_name: a title for your certificate authority.
        organization: the name of your company for your certificate authority.
        domain: the name of your company for your certificate authority.
        ca_duration: the validity of the certificate authority in seconds.
    """

    ca_service_client = privateca_v1.CertificateAuthorityServiceClient()

    # Set the type of Algorithm
    key_version_spec = privateca_v1.CertificateAuthority.KeyVersionSpec(
        algorithm=privateca_v1.CertificateAuthority.SignHashAlgorithm.RSA_PKCS1_4096_SHA256
    )

    # Set CA subject config.
    subject_config = privateca_v1.CertificateConfig.SubjectConfig(
        subject=privateca_v1.Subject(
            common_name=common_name, organization=organization
        ),
        # Set the fully qualified domain name.
        subject_alt_name=privateca_v1.SubjectAltNames(dns_names=[domain]),
    )

    # Set the key usage options for X.509 fields.
    x509_parameters = privateca_v1.X509Parameters(
        key_usage=privateca_v1.KeyUsage(
            base_key_usage=privateca_v1.KeyUsage.KeyUsageOptions(
                crl_sign=True,
                cert_sign=True,
            )
        ),
        ca_options=privateca_v1.X509Parameters.CaOptions(
            is_ca=True,
        ),
    )

    # Set certificate authority settings.
    certificate_authority = privateca_v1.CertificateAuthority(
        type_=privateca_v1.CertificateAuthority.Type.SUBORDINATE,
        key_spec=key_version_spec,
        config=privateca_v1.CertificateConfig(
            subject_config=subject_config,
            x509_config=x509_parameters,
        ),
        # Set the CA validity duration.
        lifetime=duration_pb2.Duration(seconds=ca_duration),
    )

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

    # Create the CertificateAuthorityRequest.
    request = privateca_v1.CreateCertificateAuthorityRequest(
        parent=ca_pool_path,
        certificate_authority_id=subordinate_ca_name,
        certificate_authority=certificate_authority,
    )

    operation = ca_service_client.create_certificate_authority(request=request)
    result = operation.result()

    print(f"Operation result: {result}")

Habilita una AC subordinada

Para habilitar una AC subordinada, haz lo siguiente:

Console

1. Ve a la página Certificate Authority Service en la consola de Google Cloud.

   Ir a Certificate Authority Service

2. Haz clic en la pestaña AC manager.

3. En Autoridades certificadoras, selecciona la AC que deseas activar.

4. Haz clic en Activar.

5. En el cuadro de diálogo que se abre, haz clic en Descargar CSR para descargar la Archivo de CSR con codificación PEM que la AC emisora puede firmar.

6. Haz clic en Siguiente.

7. En el campo Subir cadena de certificados, haz clic en Explorar.

8. Sube el archivo de certificado firmado con la extensión .crt.

9. Haz clic en Activar.

gcloud

Para habilitar una AC subordinada recién creada, ejecuta el siguiente comando:

gcloud privateca subordinates enable SUBORDINATE_CA_ID --pool=SUBORDINATE_POOL_ID

Reemplaza lo siguiente:

• SUBORDINATE_CA_ID: Es el identificador único de la AC subordinada.
• SUBORDINATE_POOL_ID: Es el nombre del grupo de AC que contiene la AC subordinada.

Para obtener más información sobre el comando gcloud privateca subordinates enable, consulta gcloud privateca subordinates enable.

Terraform

Establece el campo desired_state en ENABLED en la AC subordinada y ejecuta terraform apply.

Nota: El servicio de CA no verifica el estado de revocación de la AC raíz. antes de habilitar una AC subordinada que se encadena a ella. La única excepción a esta política es cuando creaste la AC raíz con el servicio de AC. En este caso, CA Service verifica el estado de revocación de la AC raíz diariamente. Si se revoca la AC raíz, el servicio de CA actualiza La métrica privateca.googleapis.com/ca/cert_revoked AC subordinada.

¿Qué sigue?

• Obtén más información para solicitar certificados.
• Obtén más información sobre las plantillas y políticas de emisión.