Meilleures pratiques de déconnexion unique SAML 2.0 suite à l'inactivité du fournisseur de services

Comprendre la déconnexion unique SAML 2.0 après l'expiration du délai de session

Étant donné que les systèmes d'authentification unique (SSO) SAML 2.0 permettent aux utilisateurs de se connecter à diverses applications à l'aide d'un seul ensemble d'informations d'identification, ils ont considérablement simplifié l'authentification des utilisateurs. Mais la notion de déconnexion unique (SLO) pose également des problèmes importants, notamment en ce qui concerne ce qui se produit lorsque la session d'un utilisateur expire chez un fournisseur de services (SP) car il ne s'est pas connecté. Dans ce cas, le fournisseur d'identité doit-il La session (IDP) se termine-t-elle également ?

La gestion des sessions entre le SP et l'IDP est essentielle pour garantir un accès sûr et efficace dans le contexte de SAML 2.0. Il n'est pas toujours évident, à la fin d'une session SP, si l'utilisateur doit toujours être connecté à l'IDP, ce qui pourrait avoir un impact sur d'autres applications liées au même IDP. Cela soulève des questions sur la convivialité ainsi que sur la sécurité.

De nombreuses entreprises, en particulier celles qui utilisent des interfaces telles que Microsoft Entra, doivent établir une bonne pratique claire pour gérer ces délais d'expiration de session. Est-il préférable que la session d'un SP s'arrête simplement au niveau du SP, ou cela devrait-il également entraîner un SLO qui déconnecte l'utilisateur de son compte IDP ?

À l'aide d'exemples concrets pour illustrer les techniques les plus efficaces pour gérer les délais d'expiration de session et garantir à la fois la sécurité et la convivialité, cet article examine les pratiques et normes standard pour gérer les événements SLO SAML 2.0 dans de telles situations.

Optimisation de la déconnexion unique avec la gestion du délai d'expiration de session SAML 2.0

En utilisant Noeud.js et Express, le script backend pour gérer la déconnexion unique (SLO) se concentre sur la capacité de suivre l'expiration de la session utilisateur et d'initier une séquence de déconnexion au niveau du fournisseur de services (SP) et du fournisseur d'identité (IDP). La gestion des sessions Express est au cœur de ce raisonnement. Nous établissons un point de déclenchement en configurant la session pour qu'elle se termine après une durée d'inactivité prédéterminée : dix minutes, dans notre exemple. Lorsque la session se termine, le script utilise la méthode `create_logout_request_url()} pour démarrer une demande de déconnexion SAML 2.0, qui se connecte ensuite à l'IDP (dans ce cas, Microsoft Entrée) pour mettre fin complètement à la session utilisateur. Cela améliore la sécurité en garantissant que l'utilisateur est complètement déconnecté du système.

Nous chargeons Certificats SAML et les clés dans l'application à l'aide de la commande `readFileSync()} pour activer une communication sécurisée entre le SP (MyApp) et l'IDP (Microsoft Entra). En authentifiant la demande de déconnexion, ces certificats protègent contre les déconnexions illégales et garantissent que la communication reste cryptée et confirmée. L'utilisateur est envoyé vers l'URL de demande de déconnexion après sa génération, où l'IDP gère la déconnexion et, si nécessaire, met fin à la session de l'utilisateur dans toutes les applications associées. Le maintien de la sécurité et de l’intégrité des installations d’authentification unique (SSO) multi-applications nécessite cette communication bidirectionnelle.

Le script JavaScript est essentiel pour suivre les activités des utilisateurs en temps réel sur le front-end. Chaque fois que l'utilisateur interagit avec le programme, nous réinitialisons le délai d'expiration de la session en utilisant des écouteurs d'événements tels que `onmousemove} et `onkeypress`. Une minuterie définie avec `setTimeout()` alerte l'utilisateur et le déconnecte automatiquement du SP (MyApp) lorsque l'utilisateur devient inactif. Après la déconnexion, le processus de déconnexion SAML 2.0 précédemment couvert est démarré par le script frontend envoyant une requête SLO au backend à l'aide de `fetch()`. Cette technique garantit que l'inactivité au niveau du SP est traitée rapidement, en toute sécurité et sans faute.

Lorsque l'intégration SAML 2.0 et gestion des sessions sont combinés, l’expérience utilisateur est transparente et les normes de sécurité sont respectées. Afin d'empêcher l'utilisateur de rester authentifié plus longtemps que ce qui est autorisé en cas d'inactivité, le délai d'expiration de la session déclenche à la fois la déconnexion du SP local et la déconnexion de l'IDP. Bien que SAML 2.0 n'exige aucune conduite particulière en ce qui concerne les délais d'expiration de session, il est généralement accepté comme meilleure pratique d'utiliser l'expiration de session pour lancer un SLO. En mettant fin aux sessions inactives, il établit un équilibre entre sécurité et expérience utilisateur en permettant des déconnexions synchronisées sur diverses plates-formes connectées SSO.

// Required modules for Node.js and SAML SSO
const express = require('express');
const session = require('express-session');
const saml2 = require('saml2-js');
const app = express();

// Service Provider (SP) setup
const sp = new saml2.ServiceProvider({
  entity_id: "http://myapp.com/metadata.xml",
  private_key: fs.readFileSync("./cert/sp-private-key.pem").toString(),
  certificate: fs.readFileSync("./cert/sp-certificate.pem").toString(),
  assert_endpoint: "http://myapp.com/assert"
});

// Identity Provider (IDP) setup
const idp = new saml2.IdentityProvider({
  sso_login_url: "https://login.microsoftonline.com/sso",
  sso_logout_url: "https://login.microsoftonline.com/logout",
  certificates: fs.readFileSync("./cert/idp-certificate.pem").toString()
});

// Session management
app.use(session({
  secret: 'mySecretKey',
  resave: false,
  saveUninitialized: true,
  cookie: { maxAge: 600000 } // Set session expiration time
}));

// Middleware to handle session timeout and SLO
app.use((req, res, next) => {
  if (req.session.expires && Date.now() > req.session.expires) {
    sp.create_logout_request_url(idp, {}, (err, logout_url) => {
      if (err) return res.status(500).send("Logout error");
      return res.redirect(logout_url); // Trigger SLO
    });
  } else {
    next(); // Continue if session is valid
  }
});

app.listen(3000, () => {
  console.log("Server running on port 3000");
});

// Define variables for session timeout
let timeoutDuration = 600000; // 10 minutes
let timeoutTimer;

// Reset the timer on any user interaction
function resetTimer() {
  clearTimeout(timeoutTimer);
  timeoutTimer = setTimeout(triggerLogout, timeoutDuration);
}

// Trigger logout function
function triggerLogout() {
  alert("Session expired due to inactivity.");
  window.location.href = "/logout"; // Redirect to SP logout
}

// Monitor user actions
window.onload = resetTimer;
document.onmousemove = resetTimer;
document.onkeypress = resetTimer;

// SLO event triggered after logout
function sendSLORequest() {
  fetch('/api/slo', { method: 'POST' })
    .then(response => {
      if (response.ok) {
        console.log("SLO request sent to IDP");
      }
    })
    .catch(err => console.error("SLO request failed", err));
}

Explorer SAML 2.0 : déconnexion unique et délai d'inactivité

Comment SAML 2.0 Single Log Out (SLO) résout inactivité au niveau du fournisseur de services (SP) est un élément essentiel à gérer. Bien qu'il soit évident qu'une déconnexion manuelle au niveau du SP devrait également entraîner une déconnexion du fournisseur d'identité (IDP), les délais d'expiration de session provoqués par l'inactivité compliquent les choses. La norme SAML 2.0 n'indique pas clairement comment le SLO doit être géré à l'expiration d'une session. Cela permet toutefois d’adopter de bonnes pratiques susceptibles d’améliorer l’expérience utilisateur et la sécurité.

Par exemple, même après avoir été exclus du SP pour cause d'inactivité, les utilisateurs qui se connectent à une application telle que MyApp via Microsoft Entra (IDP) restent fréquemment connectés à l'IDP. Si l'utilisateur pense qu'il est complètement déconnecté alors que d'autres applications utilisant le même SSO sont toujours en cours d'exécution, cela pourrait augmenter problèmes de sécurité. La configuration de la gestion des sessions SAML pour imiter l'événement de délai d'attente du SP au niveau de l'IDP et garantir des déconnexions synchronisées est un moyen de réduire ce risque.

La mise en œuvre par le code frontal de techniques de détection d'inactivité est un autre facteur. Les développeurs peuvent anticiper les périodes d'inactivité et alerter les utilisateurs avant l'expiration de la session en utilisant des écouteurs d'événements pour l'activité des utilisateurs. En utilisant cela, les utilisateurs peuvent garder le contrôle de leurs sessions et s'assurer que leur Séance SSO ne fonctionne pas en continu. Dans un environnement intégré SSO, les développeurs peuvent préserver la sécurité et le confort des utilisateurs en trouvant un équilibre entre ces facteurs.