Gérer les certificats S/MIME avec l'API Gmail

Ce document explique comment utiliser les certificats d'e-mail S/MIME dans l'API Gmail.

L'API Gmail permet d'accéder par programmation aux certificats d'e-mails S/MIME pour les utilisateurs d'un domaine Google Workspace.

Un administrateur doit activer S/MIME hébergé pour le domaine afin que les certificats fonctionnent.

La norme S/MIME fournit une spécification pour le chiffrement à clé publique et la signature des données MIME. Lorsque des certificats S/MIME sont configurés dans un compte utilisateur, Gmail les utilise de la manière suivante :

  • Signez les e-mails sortants avec le certificat utilisateur et la clé privée.

  • Déchiffrez les e-mails entrants avec la clé privée de l'utilisateur.

  • Chiffrez les e-mails sortants avec le certificat et la clé publique du destinataire.

  • Validez les e-mails entrants à l'aide du certificat de l'expéditeur et de la clé publique.

Vous pouvez générer des certificats S/MIME individuels et les importer à l'aide de l'API Gmail. Chaque certificat S/MIME est associé à un alias spécifique pour un compte de messagerie utilisateur. Les alias incluent l'adresse e-mail principale et les adresses "Envoyer en tant que" personnalisées. L'API marque un seul certificat S/MIME comme certificat par défaut pour chaque alias.

Pour en savoir plus sur les alias, consultez Gérer les alias et les signatures avec l'API Gmail.

Autoriser l'accès à l'API

Pour autoriser l'accès à l'API Gmail, utilisez l'une des méthodes suivantes :

  1. Utilisez un compte de service avec délégation de l'autorité au niveau du domaine. Pour en savoir plus sur ces termes, consultez En savoir plus sur l'authentification et l'autorisation. Pour activer cette option, consultez Créer des identifiants d'accès.

  2. Utilisez un flux OAuth 2.0 standard qui nécessite le consentement de l'utilisateur final pour obtenir un jeton d'accès OAuth 2.0. Pour en savoir plus, consultez En savoir plus sur l'authentification et l'autorisation.

    Pour utiliser cette option, l'administrateur du domaine doit cocher la case Activer le chiffrement S/MIME pour l'envoi et la réception des e-mails dans la console d'administration Google. Pour en savoir plus, consultez Activer S/MIME hébergé dans la console d'administration Google.

Champs d'application des LCA

L'API Gmail s'appuie sur les mêmes niveaux d'accès ACL que les méthodes Gmail sendAs :

  • gmail.settings.basic : ce champ d'application est requis pour mettre à jour le S/MIME principal. SendAs

  • gmail.settings.sharing : ce champ d'application est requis pour mettre à jour le from S/MIME personnalisé.

Configurer les clés S/MIME

La ressource settings.sendAs.smimeInfo fournit plusieurs méthodes pour gérer les certificats S/MIME. Chaque certificat est associé à un alias "Envoyer en tant que" pour un utilisateur.

Pour déterminer les alias "Envoyer en tant que" d'un utilisateur, utilisez la méthode settings.sendAs.list sur la ressource settings.sendAs.

Importer une clé S/MIME

Utilisez la méthode settings.sendAs.smimeInfo.insert sur la ressource settings.sendAs.smimeInfo pour importer une nouvelle clé S/MIME pour un alias appartenant à un utilisateur. Identifiez l'alias cible à l'aide des paramètres de chemin d'accès suivants :

  • userId : adresse e-mail de l'utilisateur. Utilisez la valeur spéciale me pour indiquer l'utilisateur authentifié.

  • sendAsEmail : alias pour lequel vous importez la clé. Cette adresse e-mail apparaît dans l'en-tête From: des e-mails envoyés avec cet alias.

Le certificat S/MIME et la clé privée doivent être présents dans le champ pkcs12 au format indiqué. Aucun autre champ ne doit être défini dans la requête. Le champ pkcs12 contient à la fois la clé S/MIME de l'utilisateur et la chaîne de certificats de signature. L'API effectue des validations standards sur ce champ avant de l'accepter, en vérifiant les points suivants :

  • L'objet correspond à l'adresse e-mail spécifiée.
  • Les expirations sont valides.
  • L'autorité de certification (CA) émettrice figure dans la liste des autorités de certification approuvées par Google.
  • Les certificats respectent les contraintes techniques de Gmail.

Si la clé est chiffrée, le mot de passe doit figurer dans le champ encryptedKeyPassword. Un appel de méthode settings.sendAs.smimeInfo.insert réussi renvoie la ressource settings.sendAs.smimeInfo id utilisée pour faire référence à la clé à l'avenir.

Lister les clés S/MIME d'un utilisateur

Utilisez la méthode settings.sendAs.smimeInfo.list sur la ressource settings.sendAs.smimeInfo pour renvoyer la liste des clés S/MIME pour l'utilisateur et l'alias spécifiés. Identifiez l'alias cible à l'aide des paramètres de chemin d'accès suivants :

  • userId : adresse e-mail de l'utilisateur. Utilisez la valeur spéciale me pour indiquer l'utilisateur authentifié.

  • sendAsEmail : alias pour lequel lister les clés. Cette adresse e-mail apparaît dans l'en-tête From: des e-mails envoyés avec cet alias.

Récupérer les clés S/MIME pour un alias

Utilisez la méthode settings.sendAs.smimeInfo.get sur la ressource settings.sendAs.smimeInfo pour renvoyer les clés S/MIME spécifiques à un alias "Envoyer en tant que" pour un utilisateur donné. Identifiez l'alias cible à l'aide des paramètres de chemin d'accès suivants :

  • userId : adresse e-mail de l'utilisateur. Utilisez la valeur spéciale me pour indiquer l'utilisateur authentifié.

  • sendAsEmail : alias pour lequel vous récupérez les clés. Cette adresse e-mail apparaît dans l'en-tête From: des e-mails envoyés avec cet alias.

Supprimer une clé S/MIME

Utilisez la méthode settings.sendAs.smimeInfo.delete sur la ressource settings.sendAs.smimeInfo pour supprimer la clé S/MIME spécifiée d'un alias. Identifiez l'alias cible à l'aide des paramètres de chemin d'accès suivants :

  • userId : adresse e-mail de l'utilisateur. Utilisez la valeur spéciale me pour indiquer l'utilisateur authentifié.

  • sendAsEmail : alias pour lequel vous supprimez les clés. Cette adresse e-mail apparaît dans l'en-tête From: des e-mails envoyés avec cet alias.

  • id : ID immuable du smimeInfo.

Définir la clé S/MIME par défaut pour un alias

Utilisez la méthode settings.sendAs.smimeInfo.setDefault sur la ressource settings.sendAs.smimeInfo pour marquer la clé S/MIME spécifiée comme clé par défaut pour l'alias spécifié. Identifiez l'alias cible à l'aide des paramètres de chemin d'accès suivants :

  • userId : adresse e-mail de l'utilisateur. Utilisez la valeur spéciale me pour indiquer l'utilisateur authentifié.

  • sendAsEmail : alias pour lequel définir les clés par défaut. Cette adresse e-mail apparaît dans l'en-tête From: des e-mails envoyés avec cet alias.

  • id : ID immuable du smimeInfo.

Exemples de code

Les exemples de code suivants montrent comment utiliser l'API Gmail pour gérer les certificats S/MIME d'une organisation comportant plusieurs utilisateurs :

Créer une ressource smimeInfo pour un certificat S/MIME

Cet exemple de code montre comment lire un certificat à partir d'un fichier, l'encoder en chaîne Base64URL et l'attribuer au champ pkcs12 de la ressource settings.sendAs.smimeInfo :

Java

gmail/snippets/src/main/java/CreateSmimeInfo.java
import com.google.api.services.gmail.model.SmimeInfo;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Base64;

/* Class to demonstrate the use of Gmail Create SmimeInfo API */
public class CreateSmimeInfo {
  /**
   * Create an SmimeInfo resource for a certificate from file.
   *
   * @param filename Name of the file containing the S/MIME certificate.
   * @param password Password for the certificate file, or null if the file is not
   *                 password-protected.
   * @return An SmimeInfo object with the specified certificate.
   */
  public static SmimeInfo createSmimeInfo(String filename, String password) {
    SmimeInfo smimeInfo = null;
    InputStream in = null;

    try {
      File file = new File(filename);
      in = new FileInputStream(file);
      byte[] fileContent = new byte[(int) file.length()];
      in.read(fileContent);

      smimeInfo = new SmimeInfo();
      smimeInfo.setPkcs12(Base64.getUrlEncoder().encodeToString(fileContent));
      if (password != null && password.length() > 0) {
        smimeInfo.setEncryptedKeyPassword(password);
      }
    } catch (Exception e) {
      System.out.printf("An error occured while reading the certificate file: %s\n", e);
    } finally {
      try {
        if (in != null) {
          in.close();
        }
      } catch (IOException ioe) {
        System.out.printf("An error occured while closing the input stream: %s\n", ioe);
      }
    }
    return smimeInfo;
  }
}

Python

gmail/snippet/smime snippets/create_smime_info.py
import base64


def create_smime_info(cert_filename, cert_password):
  """Create an smimeInfo resource for a certificate from file.
  Args:
    cert_filename: Name of the file containing the S/MIME certificate.
    cert_password: Password for the certificate file, or None if the file is not
        password-protected.
  Returns : Smime object, including smime information
  """

  smime_info = None
  try:
    with open(cert_filename, "rb") as cert:
      smime_info = {}
      data = cert.read().encode("UTF-8")
      smime_info["pkcs12"] = base64.urlsafe_b64encode(data).decode()
      if cert_password and len(cert_password) > 0:
        smime_info["encryptedKeyPassword"] = cert_password

  except (OSError, IOError) as error:
    print(f"An error occurred while reading the certificate file: {error}")
    smime_info = None

  return smime_info


if __name__ == "__main__":
  print(create_smime_info(cert_filename="xyz", cert_password="xyz"))

Importer un certificat S/MIME

Pour importer un certificat, appelez la méthode settings.sendAs.smimeInfo.insert et spécifiez la ressource settings.sendAs.smimeInfo dans le corps de la requête :

Java

gmail/snippets/src/main/java/InsertSmimeInfo.java
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.gmail.Gmail;
import com.google.api.services.gmail.GmailScopes;
import com.google.api.services.gmail.model.SmimeInfo;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;

/* Class to demonstrate the use of Gmail Insert Smime Certificate API*/
public class InsertSmimeInfo {
  /**
   * Upload an S/MIME certificate for the user.
   *
   * @param userId      User's email address.
   * @param sendAsEmail The "send as" email address, or null if it should be the same as userId.
   * @param smimeInfo   The SmimeInfo object containing the user's S/MIME certificate.
   * @return An SmimeInfo object with details about the uploaded certificate, {@code null} otherwise.
   * @throws IOException - if service account credentials file not found.
   */
  public static SmimeInfo insertSmimeInfo(String userId,
                                          String sendAsEmail,
                                          SmimeInfo smimeInfo)
      throws IOException {
        /* Load pre-authorized user credentials from the environment.
           TODO(developer) - See https://developers.google.com/identity for
            guides on implementing OAuth2 for your application. */
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(GmailScopes.GMAIL_SETTINGS_SHARING);
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Create the gmail API client
    Gmail service = new Gmail.Builder(new NetHttpTransport(),
        GsonFactory.getDefaultInstance(),
        requestInitializer)
        .setApplicationName("Gmail samples")
        .build();

    if (sendAsEmail == null) {
      sendAsEmail = userId;
    }

    try {
      SmimeInfo results = service.users().settings().sendAs().smimeInfo()
          .insert(userId, sendAsEmail, smimeInfo)
          .execute();
      System.out.printf("Inserted certificate, id: %s\n", results.getId());
      return results;
    } catch (IOException e) {
      System.err.printf("An error occured: %s", e);
    }
    return null;
  }
}

Python

gmail/snippet/smime snippets/insert_smime_info.py
import create_smime_info
import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def insert_smime_info():
  """Upload an S/MIME certificate for the user.
  Print the inserted certificate's id
  Returns : Result object with inserted certificate id and other meta-data

  Load pre-authorized user credentials from the environment.
  TODO(developer) - See https://developers.google.com/identity
  for guides on implementing OAuth2 for the application.
  """
  creds, _ = google.auth.default()

  try:
    # create gmail api client
    service = build("gmail", "v1", credentials=creds)

    user_id = "gduser1@workspacesamples.dev"
    smime_info = create_smime_info.create_smime_info(
        cert_filename="xyz", cert_password="xyz"
    )
    send_as_email = None

    if not send_as_email:
      send_as_email = user_id

    # pylint: disable=maybe-no-member
    results = (
        service.users()
        .settings()
        .sendAs()
        .smimeInfo()
        .insert(userId=user_id, sendAsEmail=send_as_email, body=smime_info)
        .execute()
    )
    print(f'Inserted certificate; id: {results["id"]}')

  except HttpError as error:
    print(f"An error occurred: {error}")
    results = None

  return results


if __name__ == "__main__":
  insert_smime_info()

Gérer les certificats de plusieurs utilisateurs

Ces exemples de code montrent comment gérer les certificats de plusieurs utilisateurs d'une organisation en un seul appel par lot :

Insérer des certificats à partir d'un fichier CSV

Voici un exemple de fichier CSV listant les ID utilisateur et le chemin d'accès au certificat de chaque utilisateur :

$ cat certificates.csv
user1@example.com,/path/to/user1_cert.p12,cert_password_1
user2@example.com,/path/to/user2_cert.p12,cert_password_2
user3@example.com,/path/to/user3_cert.p12,cert_password_3

Java

Vous pouvez utiliser les exemples CreateSmimeInfo et InsertSmimeInfo pour importer les certificats des utilisateurs spécifiés dans un fichier CSV :

gmail/snippets/src/main/java/InsertCertFromCsv.java
import com.google.api.services.gmail.model.SmimeInfo;
import java.io.File;
import org.apache.commons.csv.CSVFormat;
import org.apache.commons.csv.CSVParser;
import org.apache.commons.csv.CSVRecord;

/* Class to demonstrate the use of Gmail Insert Certificate from CSV File */
public class InsertCertFromCsv {
  /**
   * Upload S/MIME certificates based on the contents of a CSV file.
   *
   * <p>Each row of the CSV file should contain a user ID, path to the certificate, and the
   * certificate password.
   *
   * @param csvFilename Name of the CSV file.
   */
  public static void insertCertFromCsv(String csvFilename) {
    try {
      File csvFile = new File(csvFilename);
      CSVParser parser =
          CSVParser.parse(csvFile, java.nio.charset.StandardCharsets.UTF_8, CSVFormat.DEFAULT);
      for (CSVRecord record : parser) {
        String userId = record.get(0);
        String certFilename = record.get(1);
        String certPassword = record.get(2);
        SmimeInfo smimeInfo = CreateSmimeInfo.createSmimeInfo(certFilename,
            certPassword);
        if (smimeInfo != null) {
          InsertSmimeInfo.insertSmimeInfo(userId,
              userId,
              smimeInfo);
        } else {
          System.err.printf("Unable to read certificate file for userId: %s\n", userId);
        }
      }
    } catch (Exception e) {
      System.err.printf("An error occured while reading the CSV file: %s", e);
    }
  }
}

Python

Vous pouvez utiliser les exemples create_smime_info et insert_smime_info pour importer les certificats des utilisateurs spécifiés dans un fichier CSV :

gmail/snippet/smime snippets/insert_cert_from_csv.py
import csv

import create_smime_info
import insert_smime_info


def insert_cert_from_csv(csv_filename):
  """Upload S/MIME certificates based on the contents of a CSV file.
  Each row of the CSV file should contain a user ID, path to the certificate,
  and the certificate password.

  Args:
    csv_filename: Name of the CSV file.
  """

  try:
    with open(csv_filename, "rb") as cert:
      csv_reader = csv.reader(cert, delimiter=",")
      next(csv_reader, None)  # skip CSV file header
      for row in csv_reader:
        user_id = row[0]
        cert_filename = row[1]
        cert_password = row[2]
        smime_info = create_smime_info.create_smime_info(
            cert_filename=cert_filename, cert_password=cert_password
        )
        if smime_info:
          insert_smime_info.insert_smime_info()
        else:
          print(f"Unable to read certificate file for user_id: {user_id}")
        return smime_info

  except (OSError, IOError) as error:
    print(f"An error occured while reading the CSV file: {error}")


if __name__ == "__main__":
  insert_cert_from_csv(csv_filename="xyz")

Gestion des certificats

Cet exemple combine plusieurs méthodes de la ressource settings.sendAs.smimeInfo pour montrer comment gérer les certificats de votre organisation. Elle liste les certificats de l'utilisateur. Si le certificat par défaut a expiré ou n'est pas défini, il importe le certificat trouvé dans le fichier spécifié. Il définit ensuite comme certificat par défaut celui dont la date d'expiration est la plus éloignée.

Cette fonction traite ensuite un fichier CSV, comme dans l'exemple précédent Insérer des certificats à partir d'un fichier CSV.

Java

gmail/snippets/src/main/java/UpdateSmimeCerts.java
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.gmail.Gmail;
import com.google.api.services.gmail.GmailScopes;
import com.google.api.services.gmail.model.ListSmimeInfoResponse;
import com.google.api.services.gmail.model.SmimeInfo;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;

/* Class to demonstrate the use of Gmail Update Smime Certificate API*/
public class UpdateSmimeCerts {
  /**
   * Update S/MIME certificates for the user.
   *
   * <p>First performs a lookup of all certificates for a user. If there are no certificates, or
   * they all expire before the specified date/time, uploads the certificate in the specified file.
   * If the default certificate is expired or there was no default set, chooses the certificate with
   * the expiration furthest into the future and sets it as default.
   *
   * @param userId       User's email address.
   * @param sendAsEmail  The "send as" email address, or None if it should be the same as user_id.
   * @param certFilename Name of the file containing the S/MIME certificate.
   * @param certPassword Password for the certificate file, or None if the file is not
   *                     password-protected.
   * @param expireTime   DateTime object against which the certificate expiration is compared. If
   *                     None, uses the current time. @ returns: The ID of the default certificate.
   * @return The ID of the default certificate, {@code null} otherwise.
   * @throws IOException - if service account credentials file not found.
   */
  public static String updateSmimeCerts(String userId,
                                        String sendAsEmail,
                                        String certFilename,
                                        String certPassword,
                                        LocalDateTime expireTime)
      throws IOException {
        /* Load pre-authorized user credentials from the environment.
           TODO(developer) - See https://developers.google.com/identity for
            guides on implementing OAuth2 for your application. */
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(GmailScopes.GMAIL_SETTINGS_SHARING);
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Create the gmail API client
    Gmail service = new Gmail.Builder(new NetHttpTransport(),
        GsonFactory.getDefaultInstance(),
        requestInitializer)
        .setApplicationName("Gmail samples")
        .build();

    if (sendAsEmail == null) {
      sendAsEmail = userId;
    }

    ListSmimeInfoResponse listResults;
    try {
      listResults =
          service.users().settings().sendAs().smimeInfo().list(userId, sendAsEmail).execute();
    } catch (IOException e) {
      System.err.printf("An error occurred during list: %s\n", e);
      return null;
    }

    String defaultCertId = null;
    String bestCertId = null;
    LocalDateTime bestCertExpire = LocalDateTime.MIN;

    if (expireTime == null) {
      expireTime = LocalDateTime.now();
    }
    if (listResults != null && listResults.getSmimeInfo() != null) {
      for (SmimeInfo smimeInfo : listResults.getSmimeInfo()) {
        String certId = smimeInfo.getId();
        boolean isDefaultCert = smimeInfo.getIsDefault();
        if (isDefaultCert) {
          defaultCertId = certId;
        }
        LocalDateTime exp =
            LocalDateTime.ofInstant(
                Instant.ofEpochMilli(smimeInfo.getExpiration()), ZoneId.systemDefault());
        if (exp.isAfter(expireTime)) {
          if (exp.isAfter(bestCertExpire)) {
            bestCertId = certId;
            bestCertExpire = exp;
          }
        } else {
          if (isDefaultCert) {
            defaultCertId = null;
          }
        }
      }
    }
    if (defaultCertId == null) {
      String defaultId = bestCertId;
      if (defaultId == null && certFilename != null) {
        SmimeInfo smimeInfo = CreateSmimeInfo.createSmimeInfo(certFilename,
            certPassword);
        SmimeInfo insertResults = InsertSmimeInfo.insertSmimeInfo(userId,
            sendAsEmail,
            smimeInfo);
        if (insertResults != null) {
          defaultId = insertResults.getId();
        }
      }

      if (defaultId != null) {
        try {
          service.users().settings().sendAs().smimeInfo().setDefault(userId, sendAsEmail, defaultId)
              .execute();
          return defaultId;
        } catch (IOException e) {
          System.err.printf("An error occured during setDefault: %s", e);
        }
      }
    } else {
      return defaultCertId;
    }

    return null;
  }
}

Python

gmail/snippet/smime snippets/update_smime_cert.py
from datetime import datetime

import create_smime_info
import google.auth
import insert_smime_info
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def update_smime_cert(
    user_id, send_as_email, cert_filename, cert_password, expire_dt
):
  """Update S/MIME certificates for the user.

  First performs a lookup of all certificates for a user.  If there are no
  certificates, or they all expire before the specified date/time, uploads the
  certificate in the specified file.  If the default certificate is expired or
  there was no default set, chooses the certificate with the expiration furthest
  into the future and sets it as default.

  Args:
    user_id: User's email address.
    send_as_email: The "send as" email address, or None if it should be the same
        as user_id.
    cert_filename: Name of the file containing the S/MIME certificate.
    cert_password: Password for the certificate file, or None if the file is not
        password-protected.
    expire_dt: DateTime object against which the certificate expiration is
      compared.  If None, uses the current time.

  Returns:
    The ID of the default certificate.

  Load pre-authorized user credentials from the environment.
  TODO(developer) - See https://developers.google.com/identity
  for guides on implementing OAuth2 for the application.
  """
  if not send_as_email:
    send_as_email = user_id

  creds, _ = google.auth.default()

  try:
    # create gmail api client
    service = build("gmail", "v1", credentials=creds)

    # pylint: disable=maybe-no-member
    results = (
        service.users()
        .settings()
        .sendAs()
        .smimeInfo()
        .list(userId=user_id, sendAsEmail=send_as_email)
        .execute()
    )

  except HttpError as error:
    print(f"An error occurred during list: {error}")
    return None

  default_cert_id = None
  best_cert_id = (None, datetime.datetime.fromtimestamp(0))

  if not expire_dt:
    expire_dt = datetime.datetime.now()
  if results and "smimeInfo" in results:
    for smime_info in results["smimeInfo"]:
      cert_id = smime_info["id"]
      is_default_cert = smime_info["isDefault"]
      if is_default_cert:
        default_cert_id = cert_id
      exp = datetime.datetime.fromtimestamp(smime_info["expiration"] / 1000)
      if exp > expire_dt:
        if exp > best_cert_id[1]:
          best_cert_id = (cert_id, exp)
      else:
        if is_default_cert:
          default_cert_id = None

  if not default_cert_id:
    default_id = best_cert_id[0]
    if not default_id and cert_filename:
      create_smime_info.create_smime_info(
          cert_filename=cert_filename, cert_password=cert_password
      )
      results = insert_smime_info.insert_smime_info()
      if results:
        default_id = results["id"]

    if default_id:
      try:
        # pylint: disable=maybe-no-member
        service.users().settings().sendAs().smimeInfo().setDefault(
            userId=user_id, sendAsEmail=send_as_email, id=default_id
        ).execute()
        return default_id
      except HttpError as error:
        print(f"An error occurred during setDefault: {error}")
  else:
    return default_cert_id

  return None


if __name__ == "__main__":
  update_smime_cert(
      user_id="xyz",
      send_as_email=None,
      cert_filename="xyz",
      cert_password="xyz",
      expire_dt=None,
  )