Valider les requêtes provenant de Google Chat

Pour les applications Google Chat basées sur des points de terminaison HTTP, cette section explique comment vérifier que les requêtes envoyées à votre point de terminaison proviennent de Chat.

Pour distribuer les événements d'interaction au point de terminaison de votre application Chat, Google envoie des requêtes HTTPS à votre service. Pour vérifier que la requête provient de Google, Chat inclut un jeton d'identification OpenID Connect (OIDC) signé par Google en tant que jeton du porteur dans l'en-tête Authorization de chaque requête HTTPS (et dans le champ authorizationEventObject.systemIdToken du corps de la requête). Exemple :

POST
Host: yourappurl.com
Authorization: Bearer AbCdEf123456
Content-Type: application/json
User-Agent: Google-Dynamite

La chaîne AbCdEf123456 dans l'exemple précédent est le jeton d'autorisation du porteur. Ce jeton cryptographique est signé par le compte de service unique de votre application Chat par projet (service-<var>PROJECT_NUMBER</var>@gcp-sa-gsuiteaddons.iam.gserviceaccount.com). Le champ audience est défini sur l'URL du point de terminaison HTTP configurée pour votre application Chat lors de la configuration de l'application Chat.

Vous pouvez copier l'adresse e-mail du compte de service de votre application Chat depuis la section Paramètres de connexion de l'onglet Configuration de l'API Chat dans la console Google Cloud :

1. Dans la console Google Cloud, accédez à Menu menu > API et services > API et services activés > API Google Chat > Configuration :

   Accéder à la configuration de l'API Google Chat

2. Sous Fonctionnalités interactives > Paramètres de connexion, copiez l'adresse e-mail du compte de service (service-<var>PROJECT_NUMBER</var>@gcp-sa-gsuiteaddons.iam.gserviceaccount.com).

Si vous avez implémenté votre application Chat à l'aide de fonctions Cloud Run ou de Cloud Run, Cloud IAM gère automatiquement la validation des jetons lorsque vous accordez le rôle Cloud Run Invoker (roles/run.invoker) au compte de service de l'application Chat. Si votre application implémente son propre serveur HTTP, vous pouvez valider le jeton du porteur à l'aide d'une bibliothèque cliente de l'API Google Open Source :

• Java : https://github.com/google/google-api-java-client
• Python : https://github.com/google/google-api-python-client
• Node.js : https://github.com/google/google-api-nodejs-client
• .NET : https://github.com/google/google-api-dotnet-client

Si le jeton n'est pas validé pour l'application Chat, votre service doit répondre à la requête avec un code de réponse HTTPS 401 (Unauthorized).

Authentifier les requêtes à l'aide de Cloud Run Functions

Si la logique de votre fonction est implémentée à l'aide de Cloud Run Functions ou Cloud Run, assurez-vous que les URL des points de terminaison HTTP configurées sous Déclencheurs dans les paramètres de connexion de l'application Chat correspondent à l'URL du point de terminaison de votre fonction Cloud Run.

Ensuite, autorisez le compte de service de votre application Chat (service-<var>PROJECT_NUMBER</var>@gcp-sa-gsuiteaddons.iam.gserviceaccount.com, copié depuis la section Paramètres de connexion de l'onglet Configuration de l'API Chat) en tant qu'appelant en suivant les étapes suivantes :

gcloud functions add-invoker-policy-binding RECEIVING_FUNCTION \
  --member='serviceAccount:service-PROJECT_NUMBER@gcp-sa-gsuiteaddons.iam.gserviceaccount.com'

Authentifier les requêtes HTTP avec un jeton d'identité

Pour les points de terminaison HTTP, le jeton d'autorisation du porteur dans la requête est un jeton d'identification OpenID Connect (OIDC) signé par Google. Le champ email est défini sur l'adresse e-mail du compte de service de votre application Chat (service-<var>PROJECT_NUMBER</var>@gcp-sa-gsuiteaddons.iam.gserviceaccount.com), et le champ audience est défini sur l'URL du point de terminaison HTTP configurée pour recevoir la requête. Par exemple, si le point de terminaison configuré de votre application Chat est https://example.com/app/, le champ audience du jeton d'identité est https://example.com/app/.

Il s'agit de la méthode d'authentification recommandée si votre point de terminaison HTTP n'est pas hébergé sur un service compatible avec l'authentification basée sur IAM (comme Cloud Run).

Les exemples suivants montrent comment vérifier que le jeton de support a été émis par Google pour votre application Chat et qu'il est destiné au point de terminaison de votre application à l'aide de la bibliothèque cliente Google OAuth :

/**
 * Determine whether a Google Workspace add-on request is legitimate.
 * 
 * @param event Event sent from Google Workspace add-on
 * @param authorization Authorization header from the request
 * @return {boolean} Whether the request is legitimate
 */
private boolean verifyAddOnRequest(JsonNode event, String authorization) throws Exception {
  JsonFactory factory = JacksonFactory.getDefaultInstance();

  GoogleIdTokenVerifier verifier =
    new GoogleIdTokenVerifier.Builder(new ApacheHttpTransport(), factory)
      .setAudience(Collections.singletonList(HTTP_ENDPOINT))
      .build();

  String bearer = authorization.substring("Bearer ".length(), authorization.length());
  GoogleIdToken idToken = GoogleIdToken.parse(factory, bearer);
  return idToken != null
    && verifier.verify(idToken)
    && idToken.getPayload().getEmailVerified()
    && idToken.getPayload().getEmail().equals(SERVICE_ACCOUNT_EMAIL);
}

def verifyAddOnRequest() -> bool:
  """Determine whether a Google Workspace add-on request is legitimate.

  Args:
    request: Request sent from Google Workspace add-on

  Returns:
    Whether the request is legitimate
  """
  try:
    bearer = request.headers.get('Authorization')[len("Bearer "):]
    token = id_token.verify_oauth2_token(bearer, requests.Request(), HTTP_ENDPOINT)
    return token['email'] == SERVICE_ACCOUNT_EMAIL

  except:
    return False

/**
 * Determine whether a Google Workspace add-on request is legitimate.
 * 
 * @param {Object} req Request sent from Google Workspace add-on
 * @return {boolean} Whether the request is legitimate
 */
async function verifyAddOnRequest(req) {
  try {
    const authorization = req.headers.authorization;
    const idToken = authorization.substring('Bearer '.length, authorization.length);
    const ticket = await new OAuth2Client().verifyIdToken({idToken, audience: HTTP_ENDPOINT});
    return ticket.getPayload().email_verified
        && ticket.getPayload().email === SERVICE_ACCOUNT_EMAIL;
  } catch (unused) {
    return false;
  }
}

Articles associés

• Pour obtenir une présentation de l'authentification et de l'autorisation dans Google Workspace, consultez En savoir plus sur l'authentification et l'autorisation.
• Pour obtenir une présentation de l'authentification et de l'autorisation dans Chat, consultez Présentation de l'authentification.
• Configurez l'authentification et l'autorisation avec des identifiants utilisateur ou un compte de service.

gcloud functions add-invoker-policy-binding RECEIVING_FUNCTION \
  --member='serviceAccount:chat@system.gserviceaccount.com'

String CHAT_ISSUER = "chat@system.gserviceaccount.com";
JsonFactory factory = JacksonFactory.getDefaultInstance();

GoogleIdTokenVerifier verifier =
    new GoogleIdTokenVerifier.Builder(new ApacheHttpTransport(), factory)
        .setAudience(Collections.singletonList(AUDIENCE))
        .build();

GoogleIdToken idToken = GoogleIdToken.parse(factory, bearer);
return idToken != null
    && verifier.verify(idToken)
    && idToken.getPayload().getEmailVerified()
    && idToken.getPayload().getEmail().equals(CHAT_ISSUER);

# Bearer Tokens received by apps will always specify this issuer.
CHAT_ISSUER = 'chat@system.gserviceaccount.com'

try:
    # Verify valid token, signed by CHAT_ISSUER, intended for a third party.
    request = requests.Request()
    token = id_token.verify_oauth2_token(bearer, request, AUDIENCE)
    return token['email'] == CHAT_ISSUER

except:
    return False

// Bearer Tokens received by apps will always specify this issuer.
const chatIssuer = 'chat@system.gserviceaccount.com';

// Verify valid token, signed by chatIssuer, intended for a third party.
try {
  const ticket = await client.verifyIdToken({
    idToken: bearer,
    audience: audience
  });
  return ticket.getPayload().email_verified
      && ticket.getPayload().email === chatIssuer;
} catch (unused) {
  return false;
}

String CHAT_ISSUER = "chat@system.gserviceaccount.com";
JsonFactory factory = JacksonFactory.getDefaultInstance();

GooglePublicKeysManager keyManagerBuilder =
    new GooglePublicKeysManager.Builder(new ApacheHttpTransport(), factory)
        .setPublicCertsEncodedUrl(
            "https://www.googleapis.com/service_accounts/v1/metadata/x509/" + CHAT_ISSUER)
        .build();

GoogleIdTokenVerifier verifier =
    new GoogleIdTokenVerifier.Builder(keyManagerBuilder).setIssuer(CHAT_ISSUER).build();

GoogleIdToken idToken = GoogleIdToken.parse(factory, bearer);
return idToken != null
    && verifier.verify(idToken)
    && idToken.verifyAudience(Collections.singletonList(AUDIENCE))
    && idToken.verifyIssuer(CHAT_ISSUER);

# Bearer Tokens received by apps will always specify this issuer.
CHAT_ISSUER = 'chat@system.gserviceaccount.com'

try:
    # Verify valid token, signed by CHAT_ISSUER, intended for a third party.
    request = requests.Request()
    certs_url = 'https://www.googleapis.com/service_accounts/v1/metadata/x509/' + CHAT_ISSUER
    token = id_token.verify_token(bearer, request, AUDIENCE, certs_url)
    return token['iss'] == CHAT_ISSUER

except:
    return False

// Bearer Tokens received by apps will always specify this issuer.
const chatIssuer = 'chat@system.gserviceaccount.com';

// Verify valid token, signed by CHAT_ISSUER, intended for a third party.
try {
  const response = await fetch('https://www.googleapis.com/service_accounts/v1/metadata/x509/' + chatIssuer);
  const certs = await response.json();
  await client.verifySignedJwtWithCertsAsync(
    bearer, certs, audience, [chatIssuer]);
  return true;
} catch (unused) {
  return false;
}