Implementez une authentification oauth dans votre application nodejs-express à partir de zéro sans utliser passport

À première vue, le flux d'authentification OAuth semble très intimidant. Lorsque vous faites des recherches, vous tombez sur tellement de choses qui peuvent rendre la compréhension plus compliquée à cause des configurations à effectuer, entre autres. Je vous le dis tout de suite pour vous mettre à l'aise : c'est aussi facile que de faire une requête vers une API.

Dans cet article, Je vais vous expliquer en utilisant un exemple concret (Google) comment fonctionne l'authentification OAuth dans une application web, en utilisant Node.js et Express comme base. Vous allez apprendre à mettre en œuvre l'intégralité du processus par vous-même, ce qui vous permettra de le reproduire avec n'importe quelle technologie ou stack de votre choix.

Prérequis
OAuth, c'est quoi ?
Projet
Conclusion

Prérequis

Comme je le mentionne toujours dans tous mes articles sur mon blog, vous devez avoir déjà installé Node.js. Il est également important d'avoir une connaissance minimale en programmation JavaScript et d'avoir déjà installé un éditeur de code. Je vous recommande Visual Studio Code.

Voici un exemple en ligne du projet que nous allons créer dans cet article et le repos github du code complet.

OAuth, c'est quoi ?

Par définition, OAuth, pour Open Standard Authorization, est le protocole qui permet de donner accès aux informations d'un utilisateur à un site web, une application ou tout autre type de programme que j'appellerai ici consommateur. Trois parties importantes sont impliquées dans un flux OAuth : un utilisateur, un consommateur et un fournisseur. L'utilisateur, c'est le client, l'entité qui veut se connecter. Le consommateur, c'est le site web ou l'application auquel l'utilisateur essaie de se connecter. Le fournisseur, comme son nom l'indique, est le tiers par lequel l'utilisateur veut se connecter (Google, Facebook, GitHub...).

Avantages:
OAuth présente plusieurs avantages notables. Tout d'abord, il simplifie le processus d'accès à des plateformes en permettant à une application d'obtenir un accès désigné et sécurisé sans avoir à partager les identifiants d'accès de l'utilisateur. Cela signifie que les utilisateurs n'ont pas besoin de divulguer leurs mots de passe à des applications tierces, améliorant ainsi la sécurité de leurs comptes. De plus, en utilisant des jetons d'autorisation, OAuth renforce la sécurité des interactions entre applications et services en ligne, minimisant les risques de divulgation de données sensibles.
Inconvénients :
OAuth n'est pas sans inconvénients. Il se concentre principalement sur l'autorisation plutôt que sur l'authentification, ce qui signifie qu'il n'assure pas la vérification complète de l'identité des utilisateurs. Par conséquent, il est essentiel de comprendre qu'OAuth ne protège pas contre les tentatives d'usurpation d'identité ou de phishing, car il autorise l'accès sans vérifier l'authenticité de l'utilisateur. De plus, bien que l'utilisation d'OAuth réduise le risque de divulgation de mots de passe, elle ne garantit pas une protection totale contre les failles de sécurité ou les violations de données sur les plateformes tierces. Les utilisateurs doivent donc rester vigilants et conscients des autorisations qu'ils accordent aux applications tierces lorsqu'ils utilisent OAuth.

Il vous est probablement déjà arrivé d'aller sur un site web et, au moment de vous connecter, vous avez des options telles que "Se connecter avec Google", "Se connecter avec Facebook" et bien d'autres. Lorsque vous cliquez sur ces boutons, vous êtes redirigé vers la page de connexion du fournisseur (provider), vous vous connectez, puis vous êtes redirigé vers le site initial sur lequel vous avez essayé de vous connecter. Vous ne voyez que trois pages, mais en réalité, le processus comprend bien plus d'étapes que cela. Comme je l'ai mentionné précédemment, trois parties sont impliquées, et l'ensemble du processus se déroule en 7 étapes que voici :

L'utilisateur clique sur le bouton "Se connecter avec Google".
Le serveur du consommateur redirige l'utilisateur vers la page de connexion de Google.
Google accepte l'autorisation et renvoie un code au consommateur.
Le consommateur utilise le code pour demander un jeton d'accès (access_token) à Google.
Le consommateur utilise le jeton pour demander les informations de l'utilisateur à Google.
Le consommateur enregistre les informations de l'utilisateur si nécessaire.
Le consommateur redirige l'utilisateur vers la page authentifiée.

voici une illustration numerotée qui vous conduit un peu dans le flow.

illustration de toutes étapes du protocole OAuth entre utilisateur, nodejs et google

Maintenant que vous avez acquis une compréhension du protocole OAuth, nous sommes prêts à mettre en place un exemple concret. Dans cette étape, nous allons créer un flux de connexion avec Google

Projet

Tout d'abord, commençons par créer un dossier pour notre projet. Ouvrez votre terminal et exécutez les commandes suivantes :

mkdir nodeOAuth
cd nodeOAuth

Maintenant que nous avons notre dossier de projet prêt, nous pouvons procéder à l'initialisation du projet Node.js. Pour cela, nous allons utiliser npm (Node Package Manager), qui est l'outil standard pour gérer les dépendances et les packages Node.js.

Dans votre terminal, exécutez la commande suivante pour créer un fichier package.json, qui contiendra les informations sur notre projet et ses dépendances :

npm init -y

La commande -y permet de créer automatiquement le fichier package.json avec les valeurs par défaut. Vous pouvez bien sûr personnaliser ces valeurs si nécessaire en l'ommetant.

Ensuite, nous allons installer les packages nécessaires pour notre projet, notamment Express (un framework web pour Node.js) et Dotenv (pour la gestion des variables d'environnement). Exécutez ces commandes pour les installer :

npm i express dotenv
npm i -D nodemon

Une fois ces étapes terminées, notre projet est prêt à être développé. Nous allons maintenant créer nos fichiers et configurer notre serveur Express pour l'authentification OAuth avec Google. Nodemon nous permettra de relancer notre serveur chaque fois que nous effectuons un changement, et Dotenv chargera les variables d'environnement pour nous.

Pour créer notre serveur, ouvrez le dossier avec votre éditeur de code. Créez un nouveau fichier et nommez-le server.mjs, puis collez le code suivant :

import express from 'express'
import { config } from 'dotenv'

config()

const PORT = process.env.PORT || 8080

app.listen(PORT, () => {
  console.log(`Notre server est marche sur le port ${PORT}`)
})

Dans le fichier package.json, ajoutez les lignes startet devdans votre block script:

{
  "name": "my-express-app",
  "version": "1.0.0",
  "description": "A Node.js Express google oauth application",
  "main": "server.mjs",
  "scripts": {
    "start": "node app.mjs",
    "dev": "nodemon server.mjs"
  },
  "dependencies": {
    "express": "^4.17.1",
    "nodemon": "^2.0.15",
    "dotenv": "^10.0.0"
  },
  "engines": {
    "node": "14.x"
  }
}

Tout d'abord, assurez-vous de vous trouver dans le répertoire de votre projet nodeOAuth dans votre terminal. Ensuite, pour lancer votre serveur en mode développement avec la commande npm run dev, vous devrez exécuter cette commande dans votre terminal.

Vous devez enregistrer votre application au près de votre fournisseur. Suivez la vidéo au dessus pour voir et comprendre les étapes pour créer le votre avec google. N'oubliez pas d'ajouter votre idet code secret (client ID et client secret) dans un fichier .env

Votre fichier .env dans votre projet devrait être configuré comme suit :

GOOGLE_OAUTH_ID=VOTRE IDENTIFIANT ICI
GOOGLE_OAUTH_SECRET=VOTRE CODE SECRET ICI
GOOGLE_OAUTH_REDIRECT_URI=http://localhost:8080/oauth/google/callback

Veillez à remplacer "VOTRE IDENTIFIANT ICI" et "VOTRE CODE SECRET ICI" par les identifiants et le code secret réels que vous avez obtenus lors de l'enregistrement de votre application auprès de Google. L'URI de redirection doit également être défini sur "http://localhost:8080/oauth/google/callback" pour correspondre à votre configuration.

Comme mentionné précédemment, le processus se déroule en 6 étapes. Commençons par créer la première étape, qui consistera à ajouter une page avec un bouton permettant à l'utilisateur de démarrer la procédure.

Créez un dossier appelé views, puis à l'intérieur de ce dossier, créez un fichier nommé index.html. Vous pouvez ajouter le code HTML de base, ou vous pouvez utiliser le code suivant comme exemple.

Ce code crée une simple page HTML avec un bouton au milieu, stylisé à l'aide de Tailwind CSS. Vous pouvez personnaliser davantage cette page selon vos préférences.

N'oubliez pas d'ajouter le lien vers la bibliothèque Tailwind CSS dans la section <head> de votre fichier HTML.

Une fois cela fait, nous allons créer une route dans notre serveur qui renverra le fichier HTML à l'utilisateur.

Créez un dossier appelé routes, puis à l'intérieur de ce dossier, ajoutez un fichier nommé index.mjs avec le code suivant :

import { Router } from 'express'
import { fileURLToPath } from 'url'
import { dirname, join } from 'path'

const __filename = fileURLToPath(import.meta.url)
const __dirname = dirname(__filename)

const routes = Router()

routes.get('/', (req, res) => {
  res.sendFile(join(__dirname, '../views/index.html'))
})

export default routes

Maintenant, dans le fichier server.mjsnous allons importer et enregistrer cette route

import express from 'expess'
import { config } from 'dotenv'
import routes from 'routes/index.mjs'

config()

const PORT = process.env.PORT || 8080

app.use('/', routes)

app.use((req, res) => {
  res.status(404).send('Not found')
})

app.use((err, req, res, next) => {
  console.error(err.stack)
  res.status(500).send('Internal server error')
})

app.listen(PORT, () => {
  console.log(`Notre server est marche sur le port ${PORT}`)
})

Si vous n'avez pas encore démarré le serveur avec npm run dev, c'est le moment de le faire. Ensuite, vous pouvez visiter cette adresse : http://localhost:8080. Si votre fichier HTML est identique au mien, vous devriez voir ceci :

cpature d'une page de connexion avec un bouton se connecter avec google centré au milieu de la page

Remarquez bien que c'est simplement un lien qui renvoie l'utilisateur vers /oauth/google. Cette route sur notre serveur va déclencher la redirection vers la page de connexion de Google. Nous devons maintenant l'implémenter.

Dans le dossier routes, nous allons creer un nouveau fichier oAuth.mjset collez le code suivant:

import { Router } from 'express'
import { googleAuth } from '../controllers/oAuth.mjs'

const authRoutes = Router()

authRoutes.get('/google', googleAuth)

export default authRoutes

Vous l'avez bien compris, nous avons besoin d'un contrôleur pour séparer la logique du code des routes. Créez un nouveau dossier nommé controllers, puis ajoutez un fichier nommé oAuth.mjs et collez le code suivant :

import { getGoogleUrl } from '../lib/utils.mjs'

import { fileURLToPath } from 'url'
import { dirname } from 'path'

const __filename = fileURLToPath(import.meta.url)
const __dirname = dirname(__filename)

export const googleAuth = (req, res, next) => {
  const from = req.get('Referrer') || '/'
  return res.redirect(getGoogleUrl(from))
}

Cette fonction redirige simplement l'utilisateur vers la page de connexion de Google. La fonction getGoogleUrl() crée et retourne le lien de la page de connexion de Google. Dans le but de maintenir notre code propre, nous allons créer un dossier lib et ajouter un fichier utils.mjs. Dans ce fichier, nous ajouterons plusieurs fonctions utiles pour notre application. Commençons par ajouter la fonction getGoogleUrl().

import { config } from 'dotenv'

config()

export const getGoogleUrl = (from) => {
  const rootUrl = `https://accounts.google.com/o/oauth2/v2/auth`

  const options = {
    redirect_uri: process.env.GOOGLE_OAUTH_REDIRECT_URI,
    client_id: process.env.GOOGLE_OAUTH_ID,
    access_type: 'offline',
    response_type: 'code',
    prompt: 'consent',
    scope: [
      'https://www.googleapis.com/auth/userinfo.profile',
      'https://www.googleapis.com/auth/userinfo.email',
    ].join(' '),
    state: from,
  }

  const qs = new URLSearchParams(options)

  return `${rootUrl}?${qs.toString()}`
}

Si vous regardez le code de près, vous verrez que dans l'objet options, nous ajoutons les informations que nous avons mises dans le fichier .env lors de la création de notre application dans Google Cloud. Ces informations incluent l'URL de redirection, l'ID client, le type d'accès, le type de réponse, la demande de consentement de l'utilisateur, la portée des autorisations et l'état provenant de la requête d'origine. Toutes ces informations sont nécessaires pour configurer la redirection vers la page de connexion de Google avec les paramètres appropriés.

Avant de tester, nous devons enregistrer la nouvelle route dans Express. Importez-la dans le fichier server.mjs comme suit :

import express from 'express'
import { config } from 'dotenv'
import routes from './routes/index.mjs' // Importez correctement les routes ici
import oAuthRoutes from './routes/oAuth.mjs' // Importez correctement les routes ici

config()

const PORT = process.env.PORT || 8080

app.use('/oauth', oAuthRoutes)
app.use('/', routes)

// Lorsqu'une route n'est pas trouvée, nous voulons renvoyer 404
app.use((req, res) => {
  res.status(404).send('Not found')
})

// S'il y a une erreur, nous voulons renvoyer 500
app.use((err, req, res, next) => {
  console.error(err.stack)
  res.status(500).send('Internal server error')
})

app.listen(PORT, () => {
  console.log(`Notre serveur marche sur le port ${PORT}`)
})

Assurez-vous que votre serveur est toujours en marche et allez de nouveau visiter cette adresse : http://localhost:8080 et cliquez sur le bouton "Se connecter avec Google". Vous verrez que notre application vous redirigera sur la page de connexion de Google. Continuez le processus, et il ne devrait rien se passer pour le moment.

C'est normal, Google essaie de vous rediriger vers votre application avec le code dont je parlais plus tôt. Maintenant, nous devons implémenter la route /oauth/google/callback que nous avons indiquée comme redirect_uri à Google.

Dans le fichier routes/oAuth.mjs, nous allons ajouter la route pour notre callback Google de cette façon :

import { Router } from 'express'
import { googleAuth, googleAuthCallback } from '../controllers/oAuth.mjs'

const auth = Router()

auth.get('/google', googleAuth)

auth.get('/google/callback', googleAuthCallback)

export default auth

Lorsque nos utilisateurs se connecteront avec Google, il les redirigera vers cette route avec un code. Nous allons à présent implémenter la logique de récupération du code, du jeton d'accès et des informations de notre utilisateur.

Dans le fichier controllers/oAuth.mjs, nous allons maintenant ajouter la logique à la fonction googleAuthCallback.

import {
  getGoogleUrl,
  getGoogleOauthToken,
  getGoogleUserInfo,
  generateAccessToken,
} from '../lib/utils.mjs'

import { fileURLToPath } from 'url'
import { dirname } from 'path'

const __filename = fileURLToPath(import.meta.url)
const __dirname = dirname(__filename)

export const googleAuth = (req, res, next) => {
  const from = req.get('Referrer') || '/'
  return res.redirect(getGoogleUrl(from))
}

export const googleAuthCallback = async (req, res, next) => {
  try {
    const code = req.query.code
    const pathUrl = req.query.state || '/'

    if (!code) {
      return next(new Error('Authorization code not provided!', 401))
    }

    const { access_token, id_token } = await getGoogleOauthToken(code)

    const user = await getGoogleUserInfo(id_token, access_token)

    const jwtToken = generateAccessToken(user.id)

    res.cookie('access_token', jwtToken, {
      maxAge: 1000 * 60 * 60,
      httpOnly: true,
      sameSite: 'strict',
      secure: true,
    })

    res.send(`
    <html>
      <head>
        <meta http-equiv="refresh" content="0;url=/dashboard">
      </head>
      <body>
        <p>Redirecting...</p>
      </body>
    </html>
  `)
  } catch (error) {
    return next(error)
  }
}

Voici ce qu'il se passe ici. Au début du fichier, j'ai importé quelques fonctions utilitaires que nous allons implémenter plus bas.

Ensuite, je récupère le code que Google renvoie dans l'URL en tant que paramètre. J'utilise ce code dans la fonction getGoogleOauthToken pour demander les jetons access_token et id_token à Google.

Une fois les jetons obtenus, j'appelle la fonction getGoogleUserInfo pour récupérer les informations de l'utilisateur. Avec les informations de l'utilisateur, je peux (vous pouvez) décider de les utiliser comme bon me semble. Dans notre cas, étant donné que nous sommes dans un processus d'authentification, je prends l'ID de l'utilisateur que Google nous renvoie et je le stocke dans un JSON Web Token (JWT). La fonction generateAccessToken s'occupe de cela dans le code.

Une fois que j'ai mon JWT, je décide de le mettre dans un cookie. Grâce au cookie, nous pourons vérifier à toutes les requêtes de l'utilisateur s'il est connecté ou non. Le cookie est configuré avec un httpOnly pour des raisons de sécurité, et il est sécurisé (secure: true) pour fonctionner sur des connexions HTTPS.

Pour continuer, vous devez rajouter ce bout de code dans votre fichier lib/utils.mjs

import { config } from 'dotenv'
import axios from 'axios'
import qs from 'qs'
import jwt from 'jsonwebtoken'

config()

export const getGoogleUrl = (from) => {
  const rootUrl = `https://accounts.google.com/o/oauth2/v2/auth`

  const options = {
    redirect_uri: process.env.GOOGLE_OAUTH_REDIRECT_URI,
    client_id: process.env.GOOGLE_OAUTH_ID,
    access_type: 'offline',
    response_type: 'code',
    prompt: 'consent',
    scope: [
      'https://www.googleapis.com/auth/userinfo.profile',
      'https://www.googleapis.com/auth/userinfo.email',
    ].join(' '),
    state: from,
  }

  const qs = new URLSearchParams(options)

  return `${rootUrl}?${qs.toString()}`
}

export const getGoogleOauthToken = async (code) => {
  const rootURl = 'https://oauth2.googleapis.com/token'

  const options = {
    code,
    client_id: process.env.GOOGLE_OAUTH_ID,
    client_secret: process.env.GOOGLE_OAUTH_SECRET,
    redirect_uri: process.env.GOOGLE_OAUTH_REDIRECT_URI,
    grant_type: 'authorization_code',
  }
  try {
    const { data } = await axios.post(rootURl, qs.stringify(options), {
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded',
      },
    })

    return data
  } catch (err) {
    console.log('Failed to fetch Google Oauth Tokens')
    throw new Error(err)
  }
}

export const getGoogleUserInfo = async (id_token, access_token) => {
  try {
    const { data } = await axios.get(
      `https://www.googleapis.com/oauth2/v1/userinfo?alt=json&access_token=${access_token}`,
      {
        headers: {
          Authorization: `Bearer ${id_token}`,
        },
      }
    )

    return data
  } catch (err) {
    console.log(err)
    throw Error(err)
  }
}

export const generateAccessToken = (id) => {
  const token = jwt.sign({ id }, process.env.JWT_SECRET, {
    expiresIn: 60 * 60,
  })
  return token
}

Dans la fonction getGoogleOauthToken, si vous regardez dans les options, nous avons ajouté code, qui est le code que Google nous renvoie par le callback. Cette fonction retourne les deux tokens que nous utilisons dans getGoogleUserInfo pour aller demander les informations de notre utilisateur qui sont dans les scopes que nous avons ajoutés sur notre écran de consentement.

Nous avons certaines dépendances supplémentaires à ajouter : axios, jsonwebtoken, qs. Vous pouvez les ajouter en utilisant npm. Ouvrez votre terminal et exécutez les commandes suivantes :

npm install axios jsonwebtoken qs

Cela installera ces dépendances dans votre projet.

Maintenant nous commençons à avoir un système fonctionnel. Dans le fichier controllers/oAuth.mjs, si vous avez remarqué à la fin, je retourne ceci :

res.send(`
    <html>
      <head>
        <meta http-equiv="refresh" content="0;url=/dashboard">
      </head>
      <body>
        <p>Redirecting...</p>
      </body>
    </html>
  `)

La balise meta que vous voyez là indique au navigateur de rediriger l'utilisateur vers la page /dashboard. Nous faisons cela ici pour permettre au navigateur d'enregistrer le cookie que nous avons créé avant d'essayer d'aller sur la page /dashboard. Ainsi, dans notre route /dashboard, nous allons pouvoir ajouter un middleware qui vérifie si le cookie existe (si l'utilisateur est bien authentifié) ou non. Faisons cela tout de suite.

Dans un nouveau dossier middlewares, créez un fichier auth.mjs et ajoutez le code suivant :

import { config } from 'dotenv'
import jwt from 'jsonwebtoken'

config()

export const isAuthenticated = (req, res, next) => {
  const { access_token } = req.cookies

  if (!access_token && req.path !== '/') {
    return res.redirect('/')
  }
  try {
    const decoded = jwt.verify(access_token, process.env.JWT_SECRET)
    req.user = decoded
    if (req.path === '/') return res.redirect('/dashboard')
    return next()
  } catch (err) {
    return res.redirect('/')
  }
}

Ce middleware isAuthenticated vérifie si l'utilisateur est authentifié en vérifiant la présence du cookie access_token. S'il n'y a pas de cookie et que la route demandée n'est pas la page d'accueil ('/'), l'utilisateur est redirigé vers la page d'accueil. Si un cookie existe, le middleware vérifie le jeton JWT pour voir s'il est valide. Si le jeton est valide, l'utilisateur est considéré comme authentifié, et le middleware ajoute les informations de l'utilisateur à l'objet req.user. Si la route demandée est la page d'accueil ('/'), l'utilisateur est redirigé vers la page de tableau de bord. Sinon, le middleware autorise la poursuite du traitement de la requête en appelant next(). Si le jeton n'est pas valide ou s'il y a une erreur, l'utilisateur est redirigé vers la page d'accueil.

Et voilà, c'est terminé ! Vous avez maintenant une méthode simple pour protéger vos routes. Nous allons importer ce middleware dans nos routes pour les protéger. Le fichier routes/index.mjs doit ressembler à ceci :

import { Router } from 'express'
import { fileURLToPath } from 'url'
import { dirname, join } from 'path'
import { isAuthenticated } from '../middlewares/auth.mjs'

const __filename = fileURLToPath(import.meta.url)
const __dirname = dirname(__filename)

const routes = Router()

routes.get('/', isAuthenticated, (req, res) => {
  res.sendFile(join(__dirname, '../views/index.html'))
})

routes.get('/dashboard', isAuthenticated, (req, res) => {
  res.sendFile(join(__dirname, '../views/dashboard.html'))
})

export default routes

Assurez-vous d'ajouter un fichier dashboard.html dans le dossier views. Si vous le souhaitez, ajoutez votre propre contenu, mais vous pouvez utiliser le mien ici;

Pour faciliter la gestion des cookies, nous allons installer cookie-parser. Ajoutez-le au projet comme ceci :

npm i cookie-parser

Nous ferons quelques modifications dans le fichier server.mjs :

import express from 'express'
import auth from './routes/oAuth.mjs'
import routes from './routes/index.mjs'
import cookieParser from 'cookie-parser'

const PORT = process.env.PORT || 8080

const app = express()

app.use(express.json())
app.use(express.urlencoded({ extended: true }))

app.use(cookieParser())

app.use(express.static('public'))

app.use('/oauth', auth)
app.use('/', routes)

app.use((req, res) => {
  res.status(404).send('Not found')
})

app.use((err, req, res, next) => {
  console.error(err.stack)
  res.status(500).send('Internal server error')
})

app.listen(PORT, () => {
  console.log(`Server listening on port ${PORT}`)
})

Cet article n'est pas un tutoriel sur les jsonwebtoken et les cookies, donc je n'ai pas approfondi ces sujets. Cependant, vous devez avoir un fichier d'environnement qui ressemble à ceci :

GOOGLE_OAUTH_ID=VOTRE ID ICI
GOOGLE_OAUTH_SECRET=VOTRE CODE SECRET ICI
GOOGLE_OAUTH_REDIRECT_URI=http://localhost:8080/oauth/google/callback
JWT_SECRET=Un_code_secret_pour_JWT

Nous y sommes ! Vous avez réussi, vous l'avez vu. C'est ça, le protocole OAuth. Le moment est venu pour vous de tester le code en vous rendant à cette adresse : http://localhost:8080. En cliquant sur le bouton "Se connecter avec Google", vous serez guidé à travers toutes les étapes et redirigé vers le tableau de bord.

Tableau de board fait avec tailwind par flowbite avec l'image de tom cook

Conclusion

En conclusion, cet article vous a présenté de manière détaillée l'ensemble des étapes du processus du protocole d'authentification Oauth. En suivant l'exemple concret de nodejs express et google, Ce guide vous a fourni les bases pour implémenter l'authentification OAuth dans votre propre application. Vous avez appris à obtenir des jetons d'accès et à sécuriser vos routes avec des middlewares.

L'authentification OAuth offre de nombreux avantages, notamment la simplification de l'accès à des plateformes tierces sans avoir à divulguer les identifiants de l'utilisateur, renforçant ainsi la sécurité des comptes. Cependant, il est important de noter qu'OAuth se concentre principalement sur l'autorisation plutôt que sur l'authentification, ce qui signifie qu'il ne garantit pas une vérification complète de l'identité des utilisateurs.

Avec les connaissances acquises ici, vous êtes prêt à explorer davantage l'authentification OAuth et à l'intégrer dans vos propres projets.