Crea un'autorità di certificazione subordinata

Questa pagina descrive come creare autorità di certificazione (CA) subordinate in un pool di CA.

Le CA subordinate sono responsabili dell'emissione dei certificati direttamente a come utenti, computer e dispositivi. Le CA subordinate sono firmate in modo criptato da una CA principale, che spesso è la CA radice. Di conseguenza, i sistemi che ritengono attendibile la CA radice ritengono automaticamente attendibili le CA subordinate e i certificati delle entità finali emessi dalle CA subordinate.

Prima di iniziare

• Assicurati di disporre del ruolo IAM Responsabile operativo servizio CA (roles/privateca.caManager) o Amministratore servizio CA (roles/privateca.admin). Per informazioni, consulta Configurare i criteri IAM.
• Crea un pool di CA.
• Seleziona la tua CA principale.

Crea una CA subordinata

Le CA subordinate sono più facili da revocare e ruotare rispetto alle CA radice. Se disponi in più scenari di emissione di certificati, puoi creare una CA subordinata ciascuno di questi scenari. L'aggiunta di più CA subordinate in un pool di CA consente di bilanciare meglio il carico delle richieste di certificato e di ottenere un QPS effettivo totale più elevato.

Per creare una CA subordinata:

Console

1. Vai alla pagina Certificate Authority Service nella console Google Cloud.

   Vai a Certificate Authority Service

2. Fai clic sulla scheda Gestore CA.

3. Fai clic su Crea CA.

   

Seleziona il tipo di CA

1. Fai clic su CA subordinata.
2. Fai clic su La CA radice si trova in Google Cloud.
3. Nel campo Valido per, inserisci la durata per la quale vuoi che il certificato dell'autorità di certificazione sia valido.
4. (Facoltativo) Scegli il livello per la CA. Il livello predefinito è Enterprise. Per ulteriori informazioni, vedi Selezionare i livelli di operazioni.
5. Fai clic su Regione per selezionare una località per la CA. Per maggiori informazioni consulta la sezione Località.
6. (Facoltativo) In Stato inizializzato, seleziona lo stato in cui deve essere l'autorità di certificazione al momento della creazione.
7. (Facoltativo) In Configura uno scenario di emissione, fai clic su Profilo del certificato e seleziona dall'elenco il profilo del certificato più adatto alle tue esigenze. Per maggiori informazioni informazioni, consulta Profili di certificato.
8. Fai clic su Avanti.

Configurare il nome oggetto della CA

1. Nel campo Organizzazione (O), inserisci il nome della tua azienda.
2. (Facoltativo) Nel campo Unità organizzativa (OU), inserisci la suddivisione dell'azienda o la business unit.
3. (Facoltativo) Nel campo Nome paese, inserisci un codice paese di due lettere.
4. (Facoltativo) Nel campo Nome stato o provincia, inserisci il nome del tuo stato.
5. (Facoltativo) Nel campo Nome località, inserisci il nome della tua città.
6. Nel campo Nome comune della CA (CN), inserisci il nome della CA.
7. Nel campo ID pool, inserisci il nome del pool di CA. Non puoi modificare il pool di CA dopo aver creato la CA.
8. Fai clic su Avanti.

Configurare le dimensioni e l'algoritmo della chiave CA

1. Scegli l'algoritmo chiave più adatto alle tue esigenze. Per informazioni su come decidere l'algoritmo chiave adatto, consulta Scegli un algoritmo chiave.
2. Fai clic su Avanti.

Configurare gli elementi CA

I passaggi che seguono sono facoltativi. Se salti questi passaggi, lo stato predefinito impostazioni.

1. Scegli se utilizzare un sistema gestito da Google o uno autogestito nel bucket Cloud Storage.

Se non selezioni un bucket Cloud Storage autogestito, il servizio CA crea un bucket gestito da Google nella stessa posizione dell'autorità di certificazione.

2. Scegli se disattivare la pubblicazione di elenchi revoche certificati (CRL) e certificati CA nel bucket Cloud Storage.

La pubblicazione di CRL e certificato CA in un bucket Cloud Storage è abilitata per impostazione predefinita. Per disattivare queste impostazioni, fai clic sui pulsanti di attivazione/disattivazione.

3. Fai clic su Avanti.

Aggiungere etichette

I passaggi che seguono sono facoltativi.

Se vuoi aggiungere etichette alla CA:

1. Fai clic su Aggiungi elemento.
2. Nel campo Chiave 1, inserisci la chiave dell'etichetta.
3. Nel campo Valore 1, inserisci il valore dell'etichetta.
4. Se vuoi aggiungere un'altra etichetta, fai clic su Aggiungi elemento. Aggiungi poi la chiave e il valore dell'etichetta come indicato nei passaggi 2 e 3.
5. Fai clic su Avanti.

Controlla le impostazioni

Esamina attentamente tutte le impostazioni, quindi fai clic su Crea per creare la CA.

gcloud

1. Crea un pool di CA per la CA subordinata:

   gcloud privateca pools create SUBORDINATE_POOL_ID
   

   Sostituisci SUBORDINATE_POOL_ID con il nome del pool di CA.

   Per ulteriori informazioni sulla creazione di pool di CA, consulta Creare un pool di CA.

   Per ulteriori informazioni sul comando gcloud privateca pools create, consulta gcloud privateca pool create.

2. Crea una CA subordinata nel pool di CA creato.

   Nota: puoi ottenere l'ID risorsa dell'emittente (POOL_ID) copiando l'ID dal comando create oppure sfruttando il metodo 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"
   

   Quando viene creata la CA subordinata, viene restituita la seguente dichiarazione.

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

   Per visualizzare un elenco esaustivo delle impostazioni, esegui il seguente comando gcloud:

   gcloud privateca subordinates create --help
   

   Il comando restituisce esempi per creare una CA subordinata il cui emittente si trova nel servizio CA o altrove.

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

Per autenticarti al servizio CA, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione con CA Service, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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}")

Abilita una CA subordinata

Per abilitare una CA subordinata:

Console

1. Vai alla pagina Certificate Authority Service in la console Google Cloud.

   Vai a Certificate Authority Service

2. Fai clic sulla scheda CA Manager (Amministratore CA).

3. In Autorità di certificazione, seleziona la CA che vuoi attivare.

4. Fai clic su Attiva.

5. Nella finestra di dialogo che si apre, fai clic su Scarica CSR per scaricare il File CSR con codifica PEM che la CA emittente può firmare.

6. Fai clic su Avanti.

7. Nel campo Carica catena di certificati, fai clic su Sfoglia.

8. Carica il file del certificato firmato con l'estensione .crt.

9. Fai clic su Attiva.

gcloud

Per abilitare una CA subordinata appena creata, esegui questo comando:

gcloud privateca subordinates enable SUBORDINATE_CA_ID --pool=SUBORDINATE_POOL_ID

Sostituisci quanto segue:

• SUBORDINATE_CA_ID: l'identificatore univoco della CA subordinata.
• SUBORDINATE_POOL_ID: il nome del pool di CA che contiene la CA subordinata.

Per ulteriori informazioni sul comando gcloud privateca subordinates enable, consulta gcloud privateca subordinates enable.

Terraform

Imposta il campo desired_state su ENABLED nella CA secondaria ed esegui terraform apply.

Nota: il servizio CA non controlla lo stato di revoca della CA radice prima di abilitare una CA subordinata che si collega ad essa. L'unica eccezione a Questo criterio viene applicato se hai creato la CA radice utilizzando il servizio CA. In questo scenario, il servizio CA controlla quotidianamente lo stato di revoca della CA principale. Se la CA principale viene revocata, il servizio CA aggiorna la metrica privateca.googleapis.com/ca/cert_revoked sulla CA subordinata.

Passaggi successivi

• Scopri come richiedere i certificati.
• Scopri di più su modelli e norme di emissione.