Concernant le glissement de l'expiration de ASP.NET's formes d'authentification et de session

1. Cela semble être impossible. Une fois coulissantes date d'expiration est activé, il est toujours déclenché. Si il existe un moyen d'accéder à la session sans l'étendre, nous n'avons pas été en mesure de le trouver.

2. Alors, comment s'attaquer à ce scénario? Nous sommes venus avec les personnes suivantes solution alternative à celui proposé à l'origine dans la question. Celui-ci est en fait plus efficace car elle permet de ne pas utiliser un service web pour téléphone à la maison, toutes les x secondes.

Si nous voulons avoir un moyen de savoir quand ASP.NET s'authentification de formulaires ou de la session a expiré, de sorte que nous pouvons pro-activement la déconnexion de l'utilisateur. Un simple javascript timer sur chaque page (comme l'a proposé par Khalid Abuhakmeh) ne suffirait pas, car l'utilisateur pourrait être de travailler avec l'application en plusieurs fenêtres de navigateur/onglets en même temps.

La première décision que nous avons fait pour rendre le problème plus simple est de prendre le temps d'expiration de la session, quelques minutes de plus que le temps d'expiration de l'authentification de formulaires. De cette façon, la session n'expire jamais avant l'authentification de formulaires. Si il y a une attente ancienne session la prochaine fois que l'utilisateur essaie d'ouvrir une session, nous abandonner à forcer une nouvelle une nouvelle.

Tout droit, donc, maintenant, nous n'avons qu'à prendre l'authentification de formulaires d'expiration en compte.

Ensuite, nous avons décidé de désactiver l'authentification par formulaires automatiques coulissantes expiration (tel que défini dans le web.config) et de créer notre propre version de celui-ci.

public static void RenewAuthenticationTicket(HttpContext currentContext)
{
    var authenticationTicketCookie = currentContext.Request.Cookies["AuthTicketNameHere"];
    var oldAuthTicket = FormsAuthentication.Decrypt(authenticationTicketCookie.Value);
    var newAuthTicket = oldAuthTicket;
    newAuthTicket = FormsAuthentication.RenewTicketIfOld(oldAuthTicket); //This triggers the regular sliding expiration functionality.
    if (newAuthTicket != oldAuthTicket)
    {
        //Add the renewed authentication ticket cookie to the response.
        authenticationTicketCookie.Value = FormsAuthentication.Encrypt(newAuthTicket);
        authenticationTicketCookie.Domain = FormsAuthentication.CookieDomain;
        authenticationTicketCookie.Path = FormsAuthentication.FormsCookiePath;
        authenticationTicketCookie.HttpOnly = true;
        authenticationTicketCookie.Secure = FormsAuthentication.RequireSSL;
        currentContext.Response.Cookies.Add(authenticationTicketCookie);
        //Here we have the opportunity to do some extra stuff.
        SetAuthenticationExpirationTicket(currentContext);
    }
}

Nous appelons cette méthode à partir de la OnPreRenderComplete cas dans notre application BasePage classe, à partir de laquelle toutes les autres pages hérite. Il fait exactement la même chose que la normale coulissantes expiration de la fonctionnalité, mais nous avons la chance de faire quelques trucs supplémentaires; par exemple appeler notre SetAuthenticationExpirationTicket méthode.

public static void SetAuthenticationExpirationTicket(HttpContext currentContext)
{
    //Take the current time, in UTC, and add the forms authentication timeout (plus one second for some elbow room ;-)
    var expirationDateTimeInUtc = DateTime.UtcNow.AddMinutes(FormsAuthentication.Timeout.TotalMinutes).AddSeconds(1);
    var authenticationExpirationTicketCookie = new HttpCookie("AuthenticationExpirationTicket");
    //The value of the cookie will be the expiration date formatted as milliseconds since 01.01.1970.
    authenticationExpirationTicketCookie.Value = expirationDateTimeInUtc.Subtract(new DateTime(1970, 1, 1)).TotalMilliseconds.ToString("F0");
    authenticationExpirationTicketCookie.HttpOnly = false; //This is important, otherwise we cannot retrieve this cookie in javascript.
    authenticationExpirationTicketCookie.Secure = FormsAuthentication.RequireSSL;
    currentContext.Response.Cookies.Add(authenticationExpirationTicketCookie);
}

Maintenant, nous avons un cookie supplémentaire à notre disposition que représente toujours la forme correcte de l'authentification des temps d'expiration, même si l'utilisateur travaille dans différentes fenêtres de navigateur/onglets. Après tout, les cookies ont un navigateur large champ d'application. Maintenant, la seule chose qui reste est une fonction javascript pour vérifier la valeur du cookie.

function CheckAuthenticationExpiration() {
    var c = $.cookie("AuthenticationExpirationTicket");
    if (c != null && c != "" && !isNaN(c)) {
        var now = new Date();
        var ms = parseInt(c, 10);
        var expiration = new Date().setTime(ms);
        if (now > expiration) location.reload(true);
    }
}

(Notez que nous utilisons jQuery Plugin Cookie récupérer le cookie.)

Mettre cette fonction dans un intervalle, et les utilisateurs seront connectés pour le moment, ses formes d'authentification a expiré. Voilà 🙂 Un supplément avantage de cette application est que vous pouvez maintenant contrôler lors de l'authentification de formulaires d'expiration est agrandi. Si vous souhaitez un tas de services web qui ne s'étendent pas à l'expiration d'un délai, il suffit de ne pas appeler la RenewAuthenticationTicket méthode pour eux.

Merci de laisser un commentaire si vous avez quelque chose à ajouter!

OriginalL'auteur maartendekker

Votre site web, la fonctionnalité devrait fonctionner sans JavaScript ou vous venez de remplacer un problème par un autre. J'ai abordé ce problème aussi, et voici comment il a été résolu:

Lorsque vous vous authentifiez puis cookie de session est créé avec la durée de vie par défaut sur 20 min. Lorsque cette expire, l'utilisateur sera déconnecté.

Lorsque l'utilisateur sélectionne "se souvenir de moi" dans le signe dans formulaire supplémentaire persistance cookie [AuthCookie] est créé à côté client et dans la base de données. Ce cookie a une durée de vie de 1 mois. Chaque fois que la page est chargée, de la session et de la persistance des données de cookie est recréé avec une nouvelle vie (normalement, vous souhaitez décrypter/crypt le billet).

Imaginez le scénario suivant. Un utilisateur a travaillé dans notre application
pendant un certain temps et puis continue à faire d'autres choses, en laissant nos
application inactif pendant 20 minutes. Ensuite, l'utilisateur retourne à notre
demande de rédiger un rapport. Lorsque l'utilisateur tente d'enregistrer, sa session est restauré avant la demande.

Une façon de faire cela est d'étendre mondiale.aspx pour gérer prerequest. Quelque chose dans le genre de:

    void application_PreRequestHandlerExecute(object sender, EventArgs e){
        ...
        if (HttpContext.Current.Handler is IRequiresSessionState) {
            if (!context.User.Identity.IsAuthenticated)
                AuthService.DefaultProvider.AuthenticateUserFromExternalSource();

AuthenticateUserFromExternalSource doit vérifier si les données de cookie correspond avec la base de données, parce que tout ce qui est stocké dans le côté client peut être changé. Si vous avez payé des services avec des droits d'accès alors vous devez vérifier si l'utilisateur a toujours ces droits, et vous pouvez ensuite recréer la session.

OriginalL'auteur Margus