Où stocker Porteur du Jeton dans MVC, Web API

Scénario

J'ai un ASP.NET l'API Web qui utilise l'authentification OAuth Flux de mots de Passe à fournir au Porteur des Jetons pour obtenir l'accès à ses ressources.

Je suis maintenant dans le processus de fabrication d'un MVC de l'application qui vont avoir besoin d'utiliser cette API.

Le plan est d'avoir les contrôleurs MVC faire des appels à l'API au nom du navigateur client.

Les requêtes ajax depuis le navigateur va frapper les contrôleurs MVC et puis les appels d'API sont faites. Les résultats sont ensuite communiqués au client sous forme de JSON et poignées en java-script.

Le client ne doivent jamais communiquer directement avec l'API.

Arriver Authentifié.

J'ai besoin de trouver la meilleure façon de gérer le Porteur du Jeton, une fois qu'il a été reçu dans le MVC application via un appel à l'api web jeton de point de terminaison.

J'ai besoin d'utiliser ce porteur de jeton pour la suite des appels à l'api.

Mon plan est de le stocker dans le System.Web.HttpContext.Current.Session["BearerToken"]

Je peux alors créer un personnalisé AuthorizationAttribute qui va vérifier pour voir si un BearerToken est présente dans la HttpContext, si elle n'est pas présente, le client devra réexaminer le jeton d'extrémité.

Cela vous semble faisable?

Je pose la question pour les peuples avis sur ce que je ne suis pas convaincu que la meilleure solution pour mon projet.

Porteur du jeton, irait dans vos en-têtes de Requête. Je crois que vous accédez à internet à l'API via l'appel AJAX. Ainsi, vous devez créer la requête AJAX de façon appropriée avec le jeton que vous avez reçu de l'API Web. Je n'ai qu'une chose semblable ici, mais sans AJAX stackoverflow.com/questions/38661090/...
Im faisant le wep appel de l'api à l'aide d'un objet HttpClient dans le MVC app

OriginalL'auteur Derek | 2016-09-13

  1. 17

    J'ai réussi à venir avec quelque chose qui je pense fonctionne très bien.

    Je suis en utilisant le Owin Middleware pour l'Authentification par Cookie.

    Au sein de l'Application MVC, j'ai un Owin fichier de Démarrage où le Cookie d'Authentification est configuré :-

     public class Startup
    {
        public void Configuration(IAppBuilder app)
        {
            //For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=316888

            app.UseCookieAuthentication(new CookieAuthenticationOptions()
            {
                AuthenticationType = "ApplicationCookie",
                LoginPath = new PathString("/Account/Login"),

            });
        }
    }

    J'ai ensuite fait un AccountController avec deux méthodes d'Action pour la connexion et À la déconnexion :-

    De La Connexion.

    public ActionResult Login(LoginModel model,string returnUrl)
{
var getTokenUrl = string.Format(ApiEndPoints.AuthorisationTokenEndpoint.Post.Token, ConfigurationManager.AppSettings["ApiBaseUri"]);
using (HttpClient httpClient = new HttpClient())
{
HttpContent content = new FormUrlEncodedContent(new[]
{
new KeyValuePair<string, string>("grant_type", "password"), 
new KeyValuePair<string, string>("username", model.EmailAddress), 
new KeyValuePair<string, string>("password", model.Password)
});
HttpResponseMessage result = httpClient.PostAsync(getTokenUrl, content).Result;
string resultContent = result.Content.ReadAsStringAsync().Result;
var token = JsonConvert.DeserializeObject<Token>(resultContent);
AuthenticationProperties options = new AuthenticationProperties();
options.AllowRefresh = true;
options.IsPersistent = true;
options.ExpiresUtc = DateTime.UtcNow.AddSeconds(int.Parse(token.expires_in));
var claims = new[]
{
new Claim(ClaimTypes.Name, model.EmailAddress),
new Claim("AcessToken", string.Format("Bearer {0}", token.access_token)),
};
var identity = new ClaimsIdentity(claims, "ApplicationCookie");
Request.GetOwinContext().Authentication.SignIn(options, identity);
}
return RedirectToAction("Index", "Home");
}

    Déconnexion

      public ActionResult LogOut()
{
Request.GetOwinContext().Authentication.SignOut("ApplicationCookie");
return RedirectToAction("Login");
}

    Protéger les Ressources

        [Authorize]
public class HomeController : Controller
{
private readonly IUserSession _userSession;
public HomeController(IUserSession userSession)
{
_userSession = userSession;
}
//GET: Home
public ActionResult Index()
{
ViewBag.EmailAddress = _userSession.Username;
ViewBag.AccessToken = _userSession.BearerToken;
return View();
}
}
public interface IUserSession
{
string Username { get; }
string BearerToken { get; }
}
public class UserSession : IUserSession
{
public string Username
{
get { return ((ClaimsPrincipal)HttpContext.Current.User).FindFirst(ClaimTypes.Name).Value; }
}
public string BearerToken
{
get { return ((ClaimsPrincipal)HttpContext.Current.User).FindFirst("AcessToken").Value; }
}
}
    Merci beaucoup pour cette
    Je suis userSession objet NULL sur mon HomeController/Index
    userSession sera nulle si vous n'êtes pas à l'aide de l'injection de dépendance dans votre application.
    oui vous avez raison, pouvez-vous m'aider à résoudre cela?
    merci Derek, j'ai réussi à fixe. solution sympa

    OriginalL'auteur Derek

  2. 2

    Puisque vous avez mentionné que vous utilisez HttpClient(). Je n'ai qu'une chose semblable à l'aide de HttpClient()-

    Obtenir un jeton

        static Dictionary<string, string> GetTokenDetails(string userName, string password)
{
Dictionary<string, string> tokenDetails = null;
try
{
using (var client = new HttpClient())
{
var login = new Dictionary<string, string>
{
{"grant_type", "password"},
{"username", userName},
{"password", password},
};
var resp = client.PostAsync("http://localhost:61086/token", new FormUrlEncodedContent(login));
resp.Wait(TimeSpan.FromSeconds(10));
if (resp.IsCompleted)
{
if (resp.Result.Content.ReadAsStringAsync().Result.Contains("access_token"))
{
tokenDetails = JsonConvert.DeserializeObject<Dictionary<string, string>>(resp.Result.Content.ReadAsStringAsync().Result);
}
}
}
}
catch (Exception ex)
{
}
return tokenDetails;
}

    Utiliser le jeton pour publier des données

    static string PostData(string token, List<KeyValuePair<string, string>> lsPostContent)
{
string response = String.Empty;
try
{
using (var client = new HttpClient())
{
FormUrlEncodedContent cont = new FormUrlEncodedContent(lsPostContent);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
var resp = client.PostAsync("https://localhost:61086/api/<your API controller>/", cont);
resp.Wait(TimeSpan.FromSeconds(10));
if (resp.IsCompleted)
{
if (resp.Result.StatusCode == HttpStatusCode.Unauthorized)
{
Console.WriteLine("Authorization failed. Token expired or invalid.");
}
else
{
response = resp.Result.Content.ReadAsStringAsync().Result;
Console.WriteLine(response);
}
}
}
}
catch (Exception ex)
{
}
return response;
}

    Même si vous stockez le Porteur du jeton dans HttpContext, vous aurez besoin de prendre soin de l'jeton date d'expiration qui est défini dans l'API du Web. La validation de l'existence de jeton juste dans la session ne va pas aider depuis l'ancien jeton ne sera pas valide après l'expiration du temps.

    OriginalL'auteur Souvik Ghosh