title: Azure AD ADAL in MVC Application - Token Expiration
body: <p>I have created a Web Application using Azure AD for authentication.
  The Access Token expires after one hour (by default).
  Since my Application mainly uses Telerik Controls it doesn't do any full page roundtrips to the server. 
  To refresh the token I have implemented a JavaScript countdown.
  I have tried different approaches</p>
  
  <ol>
  <li>Insert a hidden IFrame and refresh the content of the IFrame with a page inside my app before the  token expires</li>
  <li>Insert a hidden IFrame and refresh the content of the IFrame with the Microsoft logon link like described in this Microsoft article: <a href="https://docs.microsoft.com/en-us/azure/active-directory/active-directory-v2-protocols-implicit" rel="nofollow noreferrer">https://docs.microsoft.com/en-us/azure/active-directory/active-directory-v2-protocols-implicit</a></li>
  <li>Open a Temporary window with the Microsoft logon link</li>
  <li>I also took a look inside the ADAL JavaScript Library here: <a href="https://github.com/AzureAD/azure-activedirectory-library-for-js/tree/dev" rel="nofollow noreferrer">https://github.com/AzureAD/azure-activedirectory-library-for-js/tree/dev</a>
  but this would mean I have to rebuild the whole application</li>
  </ol>
  
  <p>All approaches did not work. Even worse: If i do a full page refresh by hitting F5 in the browser, approximately 5 minutes before the token expires, the page does not load anymore and the "loading" circle in the browser is spinning endlessly.</p>
  
  <p>Does anybody have a working approach how to deal with ADAL access tokens in MVC?</p>
  
  <p>This is the code to configure my authentication</p>
  
  <pre><code> public void ConfigureAuth(IAppBuilder app)
          {
              app.SetDefaultSignInAsAuthenticationType(CookieAuthenticationDefaults.AuthenticationType);
  
              app.UseCookieAuthentication(new CookieAuthenticationOptions() { CookieSecure = CookieSecureOption.Always });
  
              app.UseOpenIdConnectAuthentication(
                  new OpenIdConnectAuthenticationOptions
                  {
                      ClientId = clientId,
                      Authority = "https://login.microsoftonline.com/common/",
  
                      TokenValidationParameters = new System.IdentityModel.Tokens.TokenValidationParameters
                      {
                          // instead of using the default validation (validating against a single issuer value, as we do in line of business apps (single tenant apps)), 
                          // we turn off validation
                          //
                          // NOTE:
                          // * In a multitenant scenario you can never validate against a fixed issuer string, as every tenant will send a different one.
                          // * If you don’t care about validating tenants, as is the case for apps giving access to 1st party resources, you just turn off validation.
                          // * If you do care about validating tenants, think of the case in which your app sells access to premium content and you want to limit access only to the tenant that paid a fee, 
                          //       you still need to turn off the default validation but you do need to add logic that compares the incoming issuer to a list of tenants that paid you, 
                          //       and block access if that’s not the case.
                          // * Refer to the following sample for a custom validation logic: https://github.com/AzureADSamples/WebApp-WebAPI-MultiTenant-OpenIdConnect-DotNet
  
                          ValidateIssuer = false
                      },
  
                      Notifications = new OpenIdConnectAuthenticationNotifications()
                      {
                          // If there is a code in the OpenID Connect response, redeem it for an access token and refresh token, and store those away. 
                          AuthorizationCodeReceived = (context) =&gt;
                          {
                              var code = context.Code;
  
                              ClientCredential credential = new ClientCredential(clientId, appKey);
                              string tenantID = context.AuthenticationTicket.Identity.FindFirst("http://schemas.microsoft.com/identity/claims/tenantid").Value;
                              string signInUserId = context.AuthenticationTicket.Identity.FindFirst(ClaimTypes.NameIdentifier).Value;
  
                              AuthenticationContext authContext = new AuthenticationContext(string.Format("{0}/{1}", "https://login.microsoftonline.com", tenantID), new ADALTokenCache(signInUserId));
  
                              // Get the access token for AAD Graph. Doing this will also initialize the token cache associated with the authentication context
                              // In theory, you could acquire token for any service your application has access to here so that you can initialize the token cache
                              AuthenticationResult result = authContext.AcquireTokenByAuthorizationCode(code, new Uri(HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Path)), credential, "https://graph.windows.net");
  
                              return Task.FromResult(0);
                          },
  
                          RedirectToIdentityProvider = (context) =&gt;
                          {
                              // This ensures that the address used for sign in and sign out is picked up dynamically from the request
                              // this allows you to deploy your app (to Azure Web Sites, for example)without having to change settings
                              // Remember that the base URL of the address used here must be provisioned in Azure AD beforehand.
                              string appBaseUrl = context.Request.Scheme + "://" + context.Request.Host + context.Request.PathBase;
                              context.ProtocolMessage.RedirectUri = appBaseUrl + "/";
                              context.ProtocolMessage.PostLogoutRedirectUri = appBaseUrl;
  
                              return Task.FromResult(0);
                          },
  
                          AuthenticationFailed = (context) =&gt;
                          {
                              // Suppress the exception if you don't want to see the error
                              context.HandleResponse();
                              return Task.FromResult(0);
                          }
                      }
  
                  });
          }
  </code></pre>
  
  <p>This is the code in my BaseController to refresh the token before it expires. I monitor the Token Expiration client side and call this method before the Token expires:</p>
  
  <pre><code>[HttpGet]
  public ActionResult RefreshAuthenticationToken()
  {
      var refreshToken = DirectoryUserRepository.GetTokenForApplication().Result.RefreshToken;
      var newToken = DirectoryUserRepository.RefreshToken(refreshToken);
      return Json(new { TokenExpirationTimestampUTC = newToken.ExpiresOn.GetUnixTimestamp() }, JsonRequestBehavior.AllowGet);
  }
  </code></pre>
  
  <p>Here are the other missing methods</p>
  
  <pre><code>public async Task&lt;AuthenticationToken&gt; GetTokenForApplication()
          {
              string signedInUserID = ClaimsPrincipal.Current.FindFirst(ClaimTypes.NameIdentifier).Value;
              string tenantID = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/tenantid").Value;
              string userObjectID = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/objectidentifier").Value;
  
              // get a token for the Graph without triggering any user interaction (from the cache, via multi-resource refresh token, etc)
              ClientCredential clientcred = new ClientCredential(clientId, appKey);
              // initialize AuthenticationContext with the token cache of the currently signed in user, as kept in the app's database
              AuthenticationContext authenticationContext = new AuthenticationContext(aadInstance + tenantID, new ADALTokenCache(signedInUserID));
              try
              {
  
                  var authenticationResult = await authenticationContext
                      .AcquireTokenSilentAsync(
                    graphResourceID,
                    new ClientCredential(clientId, appKey),
                    new UserIdentifier(userObjectID, UserIdentifierType.UniqueId));
                  return new AuthenticationToken(authenticationResult.AccessToken) { ExpiresOn = authenticationResult.ExpiresOn, RefreshToken = authenticationResult.RefreshToken };
  
                  //return authenticationResult.AccessToken;
  
              }
              catch (AggregateException e)
              {
                  foreach (Exception inner in e.InnerExceptions)
                  {
                      if (!(inner is AdalException)) continue;
                      if (((AdalException)inner).ErrorCode == AdalError.FailedToAcquireTokenSilently)
                      {
                          authenticationContext.TokenCache.Clear();
                      }
                  }
                  throw e.InnerException;
              }
              catch (AdalException exception)
              {
                  if (exception.ErrorCode == AdalError.FailedToAcquireTokenSilently)
                  {
                      authenticationContext.TokenCache.Clear();
                      throw;
                  }
                  return null;
              }
          }
  
  
  
    public AuthenticationToken RefreshToken(string refreshToken)
          {
              string signedInUserID = ClaimsPrincipal.Current.FindFirst(ClaimTypes.NameIdentifier).Value;
              string tenantID = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/tenantid").Value;
  
              // get a token for the Graph without triggering any user interaction (from the cache, via multi-resource refresh token, etc)
              ClientCredential clientcred = new ClientCredential(clientId, appKey);
              // initialize AuthenticationContext with the token cache of the currently signed in user, as kept in the app's database
              AuthenticationContext authenticationContext = new AuthenticationContext(aadInstance + tenantID, new ADALTokenCache(signedInUserID));
              try
              {
  
                  var authenticationResult = authenticationContext
                      .AcquireTokenByRefreshToken(
                      refreshToken,
                      clientcred,
                      graphResourceID);
                  return new AuthenticationToken(authenticationResult.AccessToken) { ExpiresOn = authenticationResult.ExpiresOn, RefreshToken = authenticationResult.RefreshToken };
              }
              catch (AggregateException e)
              {
                  foreach (Exception inner in e.InnerExceptions)
                  {
                      if (!(inner is AdalException)) continue;
                      if (((AdalException)inner).ErrorCode == AdalError.FailedToAcquireTokenSilently)
                      {
                          authenticationContext.TokenCache.Clear();
                      }
                  }
                  throw e.InnerException;
              }
              catch (AdalException exception)
              {
                  if (exception.ErrorCode == AdalError.FailedToAcquireTokenSilently)
                  {
                      authenticationContext.TokenCache.Clear();
                      throw;
                  }
                  return null;
              }
          }
  </code></pre>