Práticas recomendadas de logout único SAML 2.0 após inatividade do provedor de serviços

Compreendendo o logout único do SAML 2.0 após o tempo limite da sessão

Como os sistemas SAML 2.0 Single Sign-On (SSO) permitem que os usuários façam login em vários aplicativos usando um único conjunto de credenciais, eles simplificaram consideravelmente a autenticação do usuário. Mas também há problemas significativos com a noção de Logout Único (SLO), especialmente no que diz respeito ao que ocorre quando a sessão de um usuário expira em um Provedor de Serviços (SP), uma vez que ele não efetuou login. (IDP) também termina a sessão?

A gestão de sessões entre o SP e o PDI é essencial para garantir um acesso seguro e eficiente no contexto do SAML 2.0. Nem sempre é óbvio quando uma sessão SP termina se o usuário ainda deve estar conectado ao IDP, o que pode afetar outros aplicativos vinculados ao mesmo IDP. Isso levanta questões sobre usabilidade e segurança.

Uma prática recomendada clara para lidar com esses tempos limite de sessão precisa ser estabelecida por muitas empresas, especialmente aquelas que usam interfaces como o Microsoft Entra. É melhor que a sessão de um SP pare simplesmente no nível do SP ou também deveria resultar em um SLO que desconecte o usuário de sua conta IDP?

Usando exemplos do mundo real para ilustrar as técnicas mais eficientes para lidar com tempos limite de sessão e garantir segurança e usabilidade, este documento examina práticas e padrões padrão para lidar com eventos de SLO SAML 2.0 em tais situações.

Otimizando o logout único com tratamento de tempo limite de sessão SAML 2.0

Usando Node.js e Express, o script de back-end para lidar com logout único (SLO) concentra-se na capacidade de rastrear a expiração da sessão do usuário e iniciar uma sequência de logout nos níveis do provedor de serviços (SP) e do provedor de identidade (IDP). A gestão das sessões Express está no centro deste raciocínio. Estabelecemos um ponto de gatilho definindo a sessão para terminar após um período predeterminado de inatividade – dez minutos, em nosso exemplo. Quando a sessão termina, o script usa o método `create_logout_request_url()} para iniciar uma solicitação de logout SAML 2.0, que então se conecta ao IDP (neste caso, Microsoft Entrada) para encerrar totalmente a sessão do usuário. Isso aumenta a segurança, garantindo que o usuário tenha se desconectado completamente do sistema.

Nós carregamos Certificados SAML e chaves no aplicativo usando o comando `readFileSync()} para permitir a comunicação segura entre o SP (MyApp) e o IDP (Microsoft Entra). Ao autenticar a solicitação de logout, esses certificados protegem contra logouts ilegais e garantem que a comunicação permaneça criptografada e confirmada. O usuário é enviado para o URL de solicitação de logout após sua geração, onde o IDP trata do logout e, se necessário, encerra a sessão do usuário em quaisquer aplicativos associados. Manter a segurança e a integridade das instalações de Single Sign-On (SSO) de vários aplicativos requer essa comunicação bidirecional.

O script JavaScript é essencial para rastrear as atividades do usuário em tempo real no front-end. Cada vez que o usuário interage com o programa, zeramos o tempo limite da sessão usando ouvintes de eventos como `onmousemove} e `onkeypress`. Um cronômetro definido com `setTimeout()` alerta o usuário e o desconecta automaticamente do SP (MyApp) quando o usuário fica ocioso. Após o logout, o processo de logout do SAML 2.0 abordado anteriormente é iniciado pelo script de front-end enviando uma solicitação de SLO ao back-end usando `fetch()`. Essa técnica garante que a inatividade no nível do SP seja resolvida de forma imediata, segura e sem falhas.

Quando a integração SAML 2.0 e gerenciamento de sessão são combinados, a experiência do usuário é perfeita e os padrões de segurança são mantidos. Para evitar que o usuário permaneça autenticado por mais tempo do que o permitido durante a inatividade, o tempo limite da sessão inicia tanto o logout do SP local quanto o logout do IDP. Embora o SAML 2.0 não exija nenhuma conduta específica em relação aos tempos limite da sessão, é geralmente aceito como prática recomendada usar a expiração da sessão para iniciar o SLO. Ao encerrar sessões ociosas, ele estabelece um equilíbrio entre segurança e experiência do usuário, permitindo logouts sincronizados em diversas plataformas conectadas por 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));
}

Explorando SAML 2.0: logout único e tempo limite de inatividade

Como o SAML 2.0 faz o logout único (SLO) aborda inatividade no nível do Provedor de Serviços (SP) é um componente crítico de gerenciamento. Embora seja óbvio que um logout manual no SP também deva causar um logout do Provedor de Identidade (IDP), os tempos limite da sessão causados ​​pela inatividade complicam as coisas. O padrão SAML 2.0 não indica claramente como o SLO deve ser tratado nas expirações das sessões. Isto, no entanto, permite a adoção de práticas recomendadas que podem melhorar a experiência e a segurança do usuário.

Por exemplo, mesmo depois de serem excluídos do SP devido à inatividade, os usuários que fazem login em um aplicativo como o MyApp por meio do Microsoft Entra (IDP) frequentemente permanecem conectados ao IDP. Se o usuário acreditar que está totalmente desconectado enquanto outros aplicativos que utilizam o mesmo SSO ainda estão em execução, isso poderá aumentar preocupações de segurança. Configurar o gerenciamento de sessões SAML para imitar o evento de tempo limite do SP no nível do IDP e garantir logouts sincronizados é uma forma de reduzir esse risco.

A implementação de técnicas de detecção de inatividade no código frontend é outro fator. Os desenvolvedores podem antecipar tempos de inatividade e alertar os usuários antes que a sessão expire usando ouvintes de eventos para atividade do usuário. Ao usar isso, os usuários podem manter o controle sobre suas sessões e garantir que seus Sessão de logon único não funciona continuamente. Em um ambiente integrado com SSO, os desenvolvedores podem preservar a segurança e o conforto do usuário ao encontrar um equilíbrio entre esses fatores.