Bästa tillvägagångssätt för SAML 2.0 Single Log Out efter inaktivitet hos tjänsteleverantören

Förstå SAML 2.0 Single Log Out efter sessionstimeout

Eftersom SAML 2.0 Single Sign-On (SSO)-system tillåter användare att logga in på olika applikationer med en enda uppsättning autentiseringsuppgifter, har de avsevärt förenklat användarautentisering. Men det finns också betydande problem med begreppet Single Log Out (SLO), särskilt med hänsyn till vad som händer när en användares session löper ut hos en tjänsteleverantör (SP) eftersom de inte har loggat in. I det här fallet bör identitetsleverantören (IDP) session slut också?

Sessionshantering mellan SP och IDP är avgörande för att säkerställa säker och effektiv åtkomst i SAML 2.0-sammanhang. Det är inte alltid självklart när en SP-session avslutas om användaren fortfarande ska vara ansluten till IDP, vilket kan påverka andra appar som är länkade till samma IDP. Detta väcker frågor om användbarhet såväl som säkerhet.

En tydlig bästa praxis för att hantera dessa tidsgränser för sessioner måste etableras av många företag, särskilt de som använder gränssnitt som Microsoft Entra. Är det bättre att en SP:s session bara stannar på SP-nivå, eller bör det också resultera i en SLO som loggar ut användaren från deras IDP-konto?

Med hjälp av verkliga exempel för att illustrera de mest effektiva teknikerna för att hantera sessionstimeout och garantera både säkerhet och användbarhet, undersöker detta dokument standardpraxis och standarder för hantering av SAML 2.0 SLO-händelser i sådana situationer.

Optimera Single Log Out med SAML 2.0 Session Timeout Hantering

Använder Node.js och Express, backend-skriptet för hantering av Single Log Out (SLO) fokuserar på möjligheten att spåra användarsessionens utgång och initiera en utloggningssekvens på nivåerna Service Provider (SP) och Identity Provider (IDP). Hantering av Express-sessioner är kärnan i detta resonemang. Vi upprättar en triggerpunkt genom att ställa in sessionen så att den avslutas efter en förutbestämd mängd inaktivitet – tio minuter i vårt exempel. När sessionen avslutas använder skriptet metoden `create_logout_request_url()} för att starta en SAML 2.0-utloggningsbegäran, som sedan ansluter till IDP (i det här fallet, Microsoft Entra) för att avsluta användarsessionen helt. Detta ökar säkerheten genom att garantera att användaren har loggat ut helt ur systemet.

Vi laddar SAML-certifikat och knappar in i applikationen med kommandot `readFileSync()} för att möjliggöra säker kommunikation mellan SP (MyApp) och IDP (Microsoft Entra). Genom att autentisera utloggningsförfrågan skyddar dessa certifikat mot olagliga utloggningar och garanterar att kommunikationen förblir krypterad och bekräftad. Användaren skickas till URL-adressen för utloggningsförfrågan efter att den har genererats, där IDP hanterar utloggningen och, om så krävs, avslutar användarens session över alla associerade applikationer. För att upprätthålla säkerheten och integriteten för installationer med enkel inloggning med flera applikationer (SSO) krävs denna tvåvägskommunikation.

JavaScript-skriptet är viktigt för att spåra användaraktiviteter i realtid på användargränssnittet. Varje gång användaren interagerar med programmet, återställer vi sessionens timeout genom att använda händelseavlyssnare som 'onmousemove} och 'onkeypress'. En timer som ställdes in med `setTimeout()` varnar användaren och loggar automatiskt ut dem från SP (MyApp) när användaren blir inaktiv. Efter utloggning startas SAML 2.0-utloggningsprocessen som tidigare täckts av att frontend-skriptet skickar en SLO-begäran till backend med `fetch()`. Denna teknik säkerställer att inaktivitet på SP-nivå åtgärdas snabbt, säkert och utan misslyckande.

När SAML 2.0 integration och sessionshantering kombineras, är användarupplevelsen sömlös och säkerhetsstandarder upprätthålls. För att förhindra att användaren förblir autentiserad längre än vad som är tillåtet under inaktivitet, initierar sessionstimeouten både den lokala SP-utloggningen och IDP-utloggningen. Även om SAML 2.0 inte kräver något särskilt beteende när det gäller sessionstimeout, är det allmänt accepterat som en bästa praxis att använda sessionsutgång för att initiera SLO. Genom att avsluta lediga sessioner uppnår den en balans mellan säkerhet och användarupplevelse genom att möjliggöra synkroniserade utloggningar över olika SSO-anslutna plattformar.

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

Utforska SAML 2.0: Enkel utloggning och tidsgräns för inaktivitet

Hur SAML 2.0 Single Log Out (SLO) adresserar inaktivitet på tjänsteleverantörsnivå (SP) är en kritisk komponent att hantera. Även om det är uppenbart att en manuell utloggning hos SP också bör orsaka utloggning av en identitetsleverantör (IDP), komplicerar sessionstimeouts som orsakas av inaktivitet saken. SAML 2.0-standarden anger inte tydligt hur SLO ska hanteras när sessionen löper ut. Detta möjliggör dock antagandet av bästa praxis som kan förbättra användarupplevelsen och säkerheten.

Till exempel, även efter att ha stängts ut från SP på grund av inaktivitet, förblir användare som loggar in på en applikation som MyApp via Microsoft Entra (IDP) ofta inloggade på IDP. Om användaren tror att de är helt utloggade medan andra appar som använder samma SSO fortfarande körs, kan detta öka säkerhetsproblem. Att ställa in SAML-sessionshantering för att efterlikna SP-timeouthändelsen på IDP-nivå och garantera synkroniserade utloggningar är ett sätt att minska denna risk.

Frontendkodens implementering av inaktiva detekteringstekniker är en annan faktor. Utvecklare kan förutse tider av inaktivitet och varna användare innan sessionen löper ut genom att använda händelseavlyssnare för användaraktivitet. Genom att använda detta kan användare behålla kontrollen över sina sessioner och se till att deras SSO session körs inte kontinuerligt. I en SSO-integrerad miljö kan utvecklare bevara säkerhet och användarkomfort genom att hitta en balans mellan dessa faktorer.