Best Practices for SAML 2.0 Single Log Out efter tjenesteudbyderens inaktivitet

Forstå SAML 2.0 Single Log Out efter sessionstimeout

Fordi SAML 2.0 Single Sign-On (SSO)-systemer tillader brugere at logge ind på forskellige applikationer ved hjælp af et enkelt sæt legitimationsoplysninger, har de betydeligt forenklet brugergodkendelse. Men der er også væsentlige problemer med Single Log Out (SLO)-begrebet, især med hensyn til, hvad der sker, når en brugers session udløber hos en Service Provider (SP), da de ikke er logget ind. I dette tilfælde skal identitetsudbyderen (IDP) session slutter også?

Sessionsstyring mellem SP og IDP er afgørende for at sikre sikker og effektiv adgang i forbindelse med SAML 2.0. Det er ikke altid indlysende, hvornår en SP-session slutter, om brugeren stadig skal være forbundet til IDP, hvilket kan have indflydelse på andre apps, der er knyttet til samme IDP. Dette rejser spørgsmål om brugervenlighed såvel som sikkerhed.

En klar bedste praksis til håndtering af disse sessionstimeouts skal etableres af mange virksomheder, især dem, der bruger grænseflader som Microsoft Entra. Er det bedre for en SPs session at stoppe blot på SP-niveau, eller skal det også resultere i en SLO, der logger brugeren ud af deres IDP-konto?

Ved at bruge eksempler fra den virkelige verden til at illustrere de mest effektive teknikker til at håndtere sessionstimeouts og garantere både sikkerhed og brugervenlighed, undersøger dette papir standardpraksis og standarder for håndtering af SAML 2.0 SLO-hændelser i sådanne situationer.

Optimering af Single Log Out med SAML 2.0 Session Timeout Handling

Bruger Node.js og Express, backend-scriptet til håndtering af Single Log Out (SLO) fokuserer på muligheden for at spore brugersessionens udløb og starte en logout-sekvens på Service Provider (SP) og Identity Provider (IDP) niveauer. Styring af Express-sessioner er kernen i dette ræsonnement. Vi etablerer et triggerpunkt ved at indstille sessionen til at afslutte efter en forudbestemt mængde inaktivitet - ti minutter i vores eksempel. Når sessionen slutter, bruger scriptet `create_logout_request_url()}-metoden til at starte en SAML 2.0 logout-anmodning, som derefter forbinder til IDP'en (i dette tilfælde, Microsoft Entra) for at afslutte brugersessionen helt. Dette øger sikkerheden ved at garantere, at brugeren er helt logget ud af systemet.

Vi læsser SAML certifikater og taster ind i applikationen ved hjælp af kommandoen `readFileSync()} for at aktivere sikker kommunikation mellem SP (MyApp) og IDP (Microsoft Entra). Ved at autentificere logout-anmodningen beskytter disse certifikater mod ulovlige logout og garanterer, at kommunikationen forbliver krypteret og bekræftet. Brugeren sendes til logout-anmodnings-URL'en efter den er blevet genereret, hvor IDP'en håndterer logout og, hvis det er nødvendigt, afslutter brugerens session på tværs af alle tilknyttede applikationer. Vedligeholdelse af sikkerheden og integriteten af ​​multi-applikation Single Sign-On (SSO) installationer kræver denne to-vejs kommunikation.

JavaScript-scriptet er vigtigt for at spore brugeraktiviteter i realtid på frontend. Hver gang brugeren interagerer med programmet, nulstiller vi sessionens timeout ved at bruge begivenhedslyttere som 'onmousemove} og 'onkeypress'. En timer, der blev indstillet med `setTimeout()` advarer brugeren og logger dem automatisk ud af SP (MyApp), når brugeren bliver inaktiv. Efter logout startes SAML 2.0-logoutprocessen, der tidligere var dækket, ved at frontend-scriptet sender en SLO-anmodning til backend ved hjælp af `fetch()`. Denne teknik sikrer, at inaktivitet på SP-niveau behandles hurtigt, sikkert og uden fejl.

Når SAML 2.0 integration og sessionsledelse kombineres, er brugeroplevelsen problemfri, og sikkerhedsstandarderne opretholdes. For at forhindre brugeren i at forblive autentificeret i længere tid end tilladt under inaktivitet, starter sessionstimeoutet både det lokale SP-logout og IDP-logoutet. Selvom SAML 2.0 ikke kræver nogen særlig adfærd med hensyn til sessionstimeout, er det generelt accepteret som en bedste praksis at bruge sessionsudløb til at starte SLO. Ved at afslutte inaktive sessioner skaber det en balance mellem sikkerhed og brugeroplevelse ved at aktivere synkroniserede logout på tværs af forskellige SSO-forbundne platforme.

// 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));
}

Udforskning af SAML 2.0: Single Log Out og Inaktivitet Timeout

Hvordan SAML 2.0 Single Log Out (SLO) adresserer inaktivitet på Service Provider-niveau (SP) er en kritisk komponent at administrere. Selvom det er indlysende, at en manuel logout hos SP'en også skulle forårsage en Identity Provider (IDP)-logout, komplicerer sessionstimeouts forårsaget af inaktivitet sagerne. SAML 2.0-standarden angiver ikke klart, hvordan SLO skal håndteres ved sessionsudløb. Dette giver dog mulighed for vedtagelse af bedste praksis, der kan forbedre brugeroplevelsen og sikkerheden.

For eksempel, selv efter at være blevet lukket ud af SP på grund af inaktivitet, forbliver brugere, der logger på en applikation som MyApp gennem Microsoft Entra (IDP), ofte logget på IDP. Hvis brugeren mener, at de er fuldt ud logget ud, mens andre apps, der bruger den samme SSO, stadig kører, kan dette øges sikkerhedsmæssige bekymringer. Opsætning af SAML-sessionsadministration for at efterligne SP-timeouthændelsen på IDP-niveau og garantere synkroniserede logout er en måde at reducere denne risiko.

Frontend-kodens implementering af inaktive detektionsteknikker er en anden faktor. Udviklere kan forudse tidspunkter for inaktivitet og advare brugere, før sessionen udløber, ved at bruge hændelseslyttere til brugeraktivitet. Ved at bruge dette kan brugere beholde kontrol over deres sessioner og sikre sig, at deres SSO session kører ikke kontinuerligt. I et SSO-integreret miljø kan udviklere bevare sikkerhed og brugerkomfort ved at finde en balance mellem disse faktorer.