Guide de migration du flux externe (OOB)

Présentation

Le 16 février 2022, nous avons annoncé notre intention de renforcer la sécurité des interactions Google OAuth en utilisant des flux OAuth plus sécurisés. Ce guide vous explique les changements nécessaires et la marche à suivre pour passer du flux OAuth hors bande (OOB) à des alternatives compatibles.

Cette mesure vise à protéger les utilisateurs contre les attaques par hameçonnage et usurpation d'identité d'applications lors des interactions avec les points de terminaison d'autorisation OAuth 2.0 de Google.

Qu'est-ce que l'OOB ?

Le flux OAuth hors bande (OOB), également appelé option de copier-coller manuel, est un ancien flux développé pour prendre en charge les clients installés qui ne disposent pas d'un URI de redirection pour accepter les identifiants après qu'un utilisateur a approuvé une demande de consentement OAuth. Le flux OOB présente un risque d'hameçonnage à distance, et les clients doivent migrer vers une autre méthode pour se protéger contre cette faille.

Le flux OOB est en cours d'abandon pour tous les types d'applications : applications Web, Android, iOS, Universal Windows Platform (UWP), applications Chrome, téléviseurs et périphériques d'entrée limitée, applications de bureau.

Dates clés de conformité

  • 28 février 2022 : blocage de la nouvelle utilisation d'OAuth pour le flux OOB
  • 5 septembre 2022 : un message d'avertissement visible par l'utilisateur peut s'afficher pour les requêtes OAuth non conformes.
  • 3 octobre 2022 : le flux OOB est obsolète pour les clients OAuth créés avant le 28 février 2022.
  • 31 janvier 2023 : tous les clients existants sont bloqués (y compris les clients exemptés).

Un message d'erreur visible par l'utilisateur s'affiche pour les requêtes non conformes. Le message indiquera aux utilisateurs que l'application est bloquée, tout en affichant l'adresse e-mail d'assistance que vous avez enregistrée sur l'écran de consentement OAuth dans la console Google Cloud.

La procédure de migration se déroule en deux étapes principales :

  1. Déterminez si vous êtes concerné.
  2. Si vous êtes concerné, migrez vers une alternative plus sécurisée.

Déterminer si vous êtes concerné

Cette obsolescence ne s'applique qu'aux applications de production (c'est-à-dire les applications dont l'état de publication est défini sur En production). Le flux continuera de fonctionner pour les applications dont l'état de publication est "Test".

Vérifiez l'état de publication sur la page de branding OAuth de la console Google Cloud, puis passez à l'étape suivante si vous utilisez le flux OOB dans un projet dont l'état de publication est "En production".

Comment déterminer si votre application utilise le flux OOB

Inspectez le code de votre application ou l'appel réseau sortant (si votre application utilise une bibliothèque OAuth) pour déterminer si la demande d'autorisation Google OAuth effectuée par votre application utilise une valeur d'URI de redirection OOB.

Inspecter le code de votre application

Examinez la section du code de votre application où vous effectuez des appels aux points de terminaison d'autorisation Google OAuth et déterminez si le paramètre redirect_uri comporte l'une des valeurs suivantes :

  • redirect_uri=urn:ietf:wg:oauth:2.0:oob
  • redirect_uri=urn:ietf:wg:oauth:2.0:oob:auto
  • redirect_uri=oob

Voici un exemple de requête de flux de redirection OOB :

https://accounts.google.com/o/oauth2/v2/auth?
response_type=code&
scope=<SCOPES>&
state=<STATE>&
redirect_uri=urn:ietf:wg:oauth:2.0:oob&
client_id=<CLIENT_ID>

Inspecter un appel réseau sortant

La méthode d'inspection des appels réseau varie en fonction du type d'application.

Lorsque vous inspectez les appels réseau, recherchez les requêtes envoyées aux points de terminaison d'autorisation Google OAuth et déterminez si le paramètre redirect_uri comporte l'une des valeurs suivantes :

  • redirect_uri=urn:ietf:wg:oauth:2.0:oob
  • redirect_uri=urn:ietf:wg:oauth:2.0:oob:auto
  • redirect_uri=oob

Voici un exemple de requête de flux de redirection OOB :

https://accounts.google.com/o/oauth2/v2/auth?
response_type=code&
scope=<SCOPES>&
state=<STATE>&
redirect_uri=urn:ietf:wg:oauth:2.0:oob&
client_id=<CLIENT_ID>

Migrer vers une alternative sécurisée

Clients mobiles (Android et iOS)

Si vous déterminez que votre application utilise le flux OOB avec un type d'application OAuth Android ou iOS, vous devez migrer vers les SDK recommandés (Android, iOS).

Le SDK vous aide à accéder aux API Google et gère tous les appels aux points de terminaison d'autorisation OAuth 2.0 de Google.

Les liens vers la documentation ci-dessous expliquent comment utiliser les SDK recommandés pour accéder aux API Google sans utiliser d'URI de redirection OOB.

Accéder aux API Google sur Android

Accès côté client

L'exemple suivant montre comment accéder aux API Google côté client sur Android à l'aide de la bibliothèque Android Google Identity Services recommandée.

List<Scopes> requestedScopes = Arrays.asList(DriveScopes.DRIVE_APPDATA);
AuthorizationRequest authorizationRequest =
    AuthorizationRequest.builder()
        .setRequestedScopes(requestedScopes)
        .build();
Identity.getAuthorizationClient(activity)
    .authorize(authorizationRequest)
    .addOnSuccessListener(
        authorizationResult -> {
          if (authorizationResult.hasResolution()) {
            // Access needs to be granted by the user
            PendingIntent pendingIntent =
                authorizationResult.getPendingIntent();
            try {
              startIntentSenderForResult(
                  pendingIntent.getIntentSender(),
                  REQUEST_AUTHORIZE, null, 0, 0, 0, null);
            } catch (IntentSender.SendIntentException e) {
              Log.e(
                  TAG,
                  "Couldn't start Authorization UI: "
                      + e.getLocalizedMessage());
            }
          } else {
            // Access already granted, continue with user action
            saveToDriveAppFolder(authorizationResult);
          }
        })
    .addOnFailureListener(e -> Log.e(TAG, "Failed to authorize", e));

Transmettez authorizationResult à la méthode définie pour enregistrer le contenu dans le dossier Drive de l'utilisateur. authorizationResult dispose de la méthode getAccessToken() qui renvoie le jeton d'accès.

Accès côté serveur (hors connexion)

L'exemple suivant montre comment accéder aux API Google côté serveur sur Android.

List<Scopes> requestedScopes = Arrays.asList(DriveScopes.DRIVE_APPDATA);
AuthorizationRequest authorizationRequest =
    AuthorizationRequest.builder()
        .requestOfflineAccess(webClientId)
        .setRequestedScopes(requestedScopes)
        .build();
Identity.getAuthorizationClient(activity)
    .authorize(authorizationRequest)
    .addOnSuccessListener(
        authorizationResult -> {
          if (authorizationResult.hasResolution()) {
            // Access needs to be granted by the user
            PendingIntent pendingIntent =
                authorizationResult.getPendingIntent();
            try {
              startIntentSenderForResult(
                  pendingIntent.getIntentSender(),
                  REQUEST_AUTHORIZE, null, 0, 0, 0, null);
            } catch (IntentSender.SendIntentException e) {
              Log.e(
                  TAG,
                  "Couldn't start Authorization UI: "
                      + e.getLocalizedMessage());
            }
          } else {
            String authCode =
                authorizationResult.getServerAuthCode();
          }
        })
    .addOnFailureListener(e -> Log.e(TAG, "Failed to authorize", e));

authorizationResult dispose de la méthode getServerAuthCode() qui renvoie le code d'autorisation que vous pouvez envoyer à votre backend pour obtenir un jeton d'accès et un jeton d'actualisation.

Accéder aux API Google dans une application iOS

Accès côté client

L'exemple suivant montre comment accéder aux API Google côté client sur iOS.

user.authentication.do { authentication, error in
  guard error == nil else { return }
  guard let authentication = authentication else { return }
  
  // Get the access token to attach it to a REST or gRPC request.
  let accessToken = authentication.accessToken
  
  // Or, get an object that conforms to GTMFetcherAuthorizationProtocol for
  // use with GTMAppAuth and the Google APIs client library.
  let authorizer = authentication.fetcherAuthorizer()
}

Utilisez le jeton d'accès pour appeler l'API, soit en l'incluant dans l'en-tête d'une requête REST ou gRPC (Authorization: Bearer <var>ACCESS_TOKEN</var>), soit en utilisant l'outil d'autorisation de récupération (GTMFetcherAuthorizationProtocol) avec la bibliothèque cliente des API Google pour Objective-C pour REST.

Consultez le guide d'accès côté client pour savoir comment accéder aux API Google côté client.

Accès côté serveur (hors connexion)

L'exemple suivant montre comment accéder aux API Google côté serveur pour prendre en charge un client iOS.

GIDSignIn.sharedInstance.signIn(
    with: signInConfig, presenting: self
) { user, error in
  guard error == nil else { return }
  guard let user = user else { return }
  
  // request a one-time authorization code that your server exchanges for
  // an access token and refresh token
  let authCode = user.serverAuthCode
}

Consultez le guide d'accès côté serveur pour savoir comment accéder aux API Google côté serveur.

Client Application Chrome

Si vous déterminez que votre application utilise le flux OOB sur le client d'application Chrome, vous devez migrer vers l'API Chrome Identity.

L'exemple suivant montre comment obtenir tous les contacts d'un utilisateur sans utiliser d'URI de redirection OOB.

window.onload = function() {
  document.querySelector('button').addEventListener('click', function() {

  
  // retrieve access token
  chrome.identity.getAuthToken({interactive: true}, function(token) {
  
  // ..........


  // the following example shows how to use a retrieved access token with an
  // appropriate scope to call the Google People API contactGroups.get endpoint

  fetch(
    'https://people.googleapis.com/v1/contactGroups/all'
        + '?maxMembers=20&key=API_KEY',
    init)
    .then((response) => response.json())
    .then(function(data) {
      console.log(data)
    });
   });
 });
};

Pour en savoir plus sur l'authentification des utilisateurs et l'appel de points de terminaison Google avec l'API Chrome Identity, consultez le guide de l'API Chrome Identity.

Application Web

Si vous déterminez que votre application utilise le flux OOB pour une application Web, vous devez migrer vers l'une de nos bibliothèques clientes d'API Google. Consultez la liste des bibliothèques clientes des API Google pour différents langages de programmation.

Les bibliothèques simplifient l'accès aux API Google et gèrent tous les appels aux points de terminaison Google.

Accès côté serveur (hors connexion)

Le mode d'accès côté serveur (hors connexion) nécessite d'effectuer les opérations suivantes :

  • Configurez un serveur et définissez un point de terminaison accessible publiquement (l'URI de redirection) pour recevoir le code d'autorisation.
  • Configurez l'URI de redirection sur la page Clients de la console Google Cloud.

L'extrait de code suivant montre un exemple NodeJS d'utilisation de l'API Google Drive pour lister les fichiers Google Drive d'un utilisateur côté serveur sans utiliser d'URI de redirection OOB.

async function main() {
  const server = http.createServer(async function (req, res) {

  if (req.url.startsWith('/oauth2callback')) {
    let q = url.parse(req.url, true).query;

    if (q.error) {
      console.log('Error:' + q.error);
    } else {
      
      // Get access and refresh tokens (if access_type is offline)
      let { tokens } = await oauth2Client.getToken(q.code);
      oauth2Client.setCredentials(tokens);

      // Example of using Google Drive API to list filenames in user's Drive.
      const drive = google.drive('v3');
      drive.files.list({
        auth: oauth2Client,
        pageSize: 10,
        fields: 'nextPageToken, files(id, name)',
      }, (err1, res1) => {
        // TODO(developer): Handle response / error.
      });
    }
  }
}

Consultez le guide sur les applications Web côté serveur pour savoir comment accéder aux API Google côté serveur.

Accès côté client

L'extrait de code suivant, en JavaScript, montre un exemple d'utilisation de l'API Google pour accéder aux événements d'agenda de l'utilisateur côté client.


// initTokenClient() initializes a new token client with your
// web app's client ID and the scope you need access to

const client = google.accounts.oauth2.initTokenClient({
  client_id: 'YOUR_GOOGLE_CLIENT_ID',
  scope: 'https://www.googleapis.com/auth/calendar.readonly',
  
  // callback function to handle the token response
  callback: (tokenResponse) => {
    if (tokenResponse && tokenResponse.access_token) { 
      gapi.client.setApiKey('YOUR_API_KEY');
      gapi.client.load('calendar', 'v3', listUpcomingEvents);
    }
  },
});

function listUpcomingEvents() {
  gapi.client.calendar.events.list(...);
}

Consultez le guide des applications Web côté client pour savoir comment accéder aux API Google côté client.

Client de bureau

Si vous déterminez que votre application utilise le flux OOB sur un client de bureau, vous devez migrer vers le flux d'adresse IP de bouclage (localhost ou 127.0.0.1).