title: How to store access token? (Oauth 2, Auth code flow)
body: <p>From what i understand the purpose of the Authorization Code flow is to exchange the auth code for access token. This exchange happens between the server which serves the page and authorization server so that the actual access token is not exposed to the client user.</p>
  
  <p>How should the page server store the access token once it is obtained? I was learning from a Pluralsight example in which there is this part of code:</p>
  
  <pre><code>    public static HttpClient GetClient()
      {
          HttpClient client = new HttpClient();
          var accessToken = RequestAccessTokenAuthorizationCode();
          client.SetBearerToken(accessToken);
  
          client.BaseAddress = new Uri(IdentityConstants.API);
          client.DefaultRequestHeaders.Accept.Clear();
          client.DefaultRequestHeaders.Accept.Add(
              new MediaTypeWithQualityHeaderValue("application/json"));
  
          return client;
      }
  
      private static string RequestAccessTokenAuthorizationCode()
      {
          // did we store the token before?
          var cookie = HttpContext.Current.Request.Cookies.Get("ClientMVCCookie.AuthCode");
          if (cookie != null &amp;&amp; cookie["access_token"] != null &amp;&amp; !string.IsNullOrEmpty(cookie["access_token"]))
          {
              return cookie["access_token"];
          }
  
          // no token found - request one
  
          // we'll pass through the URI we want to return to as state
          var state = HttpContext.Current.Request.Url.OriginalString;
  
          var authorizeRequest = new IdentityModel.Client.AuthorizeRequest(
              IdentityConstants.AuthEndoint);
  
          var url = authorizeRequest.CreateAuthorizeUrl(IdentityConstants.MVCClientSecret, "code", "management secret",
              IdentityConstants.MVCAuthCodeCallback, state);
  
          HttpContext.Current.Response.Redirect(url);
  
          return null;
      }
  }
  </code></pre>
  
  <p>This will cause each request to check if there is an access token stored in the cookie. If not then the flow will be initiated. The callback looks like this:</p>
  
  <pre><code>public class CallbackController : Controller
  {
      // GET: STSCallback
      public async Task&lt;ActionResult&gt; Index()
      {
          // get the authorization code from the query string
          var authCode = Request.QueryString["code"];
  
          // with the auth code, we can request an access token.
          var client = new TokenClient(
              IdentityConstants.TokenEndoint,
              "mvc_client_auth_code",
               IdentityConstants.MVCClientSecretAuthCode);
  
          var tokenResponse = await client.RequestAuthorizationCodeAsync(
              authCode,
              IdentityConstants.MVCAuthCodeCallback);
  
          // we save the token in a cookie for use later on
          var cookie = Response.Cookies["ClientMVCCookie.AuthCode"];
          cookie.Expires = DateTime.Now.AddMinutes(1);
          cookie["access_token"] = tokenResponse.AccessToken;
  
          // get the state (uri to return to)
          var state = Request.QueryString["state"];
  
          // redirect to the URI saved in state
          return Redirect(state);
      }
  }
  </code></pre>
  
  <p>Doesn't storing the access token in the cookie defeath the whole purpose of the authorization code flow? The cookie will be transmitted to the client browser thus exposing it to the client? Am i missing something? It this is not the correct way to store the token, how should it be stored?</p>