I have a VS Project I built, basically just and ASP.NET Core 5 Web Site with local Auth enabled. I can register local users, then login to them no problem. However, when I try to create a user programmatically, with the code below,I know the user is created because I can view it in SQL, however when I try and login, I get a "login access no allowed" error.
Am I somehow not creating the user correctly?
How can I debug this to see what is not validating?
public static async Task SeedDefaultUserAsync(UserManager<ApplicationUser> userManager)
{
string testUser = "user999";
var user = await userManager.FindByNameAsync(testUser);
if (user == null)
{
user = new ApplicationUser()
{
Email = testUser + "#gmail.com",
UserName = testUser,
EmailConfirmed = true,
LockoutEnabled = false,
};
await userManager.CreateAsync(user, "Abc123#");
Console.WriteLine("user: " + testUser + " available with password Abc123#.");
}
if (user == null)
{
throw new Exception("The password is probably not strong enough!");
}
}
I've even tried sending myself a password reset link, reset the password and I still get the login error.
As far as I know, when you login in asp.net core identity it will called the CanSignInAsync method to check the user could signin or not.
If user doesn't pass , it will throw the "login access no allowed" error.
More details, you could refer to below source codes:
protected virtual async Task<SignInResult> PreSignInCheck(TUser user)
{
if (!await CanSignInAsync(user))
{
return SignInResult.NotAllowed;
}
if (await IsLockedOut(user))
{
return await LockedOut(user);
}
return null;
}
public virtual async Task<bool> CanSignInAsync(TUser user)
{
if (Options.SignIn.RequireConfirmedEmail && !(await UserManager.IsEmailConfirmedAsync(user)))
{
Logger.LogWarning(0, "User cannot sign in without a confirmed email.");
return false;
}
if (Options.SignIn.RequireConfirmedPhoneNumber && !(await UserManager.IsPhoneNumberConfirmedAsync(user)))
{
Logger.LogWarning(1, "User cannot sign in without a confirmed phone number.");
return false;
}
if (Options.SignIn.RequireConfirmedAccount && !(await _confirmation.IsConfirmedAsync(UserManager, user)))
{
Logger.LogWarning(4, "User cannot sign in without a confirmed account.");
return false;
}
return true;
}
So I suggest you could check your startup.cs to make sure you have set the phone or RequireConfirmedAccount to false like below, if you have enabled other required information you should set it in your application.
Besides, by default the username is also a Email format, please modify your codes to set username to Email also. UserName = testUser + "#gmail.com",
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext<ApplicationDbContext>(options =>
options.UseSqlServer(
Configuration.GetConnectionString("DefaultConnection")));
services.AddDatabaseDeveloperPageExceptionFilter();
services.AddDefaultIdentity<IdentityUser>(options =>
{ options.SignIn.RequireConfirmedAccount = false;
options.SignIn.RequireConfirmedEmail = true;
options.SignIn.RequireConfirmedPhoneNumber = false;
})
.AddEntityFrameworkStores<ApplicationDbContext>();
services.AddControllersWithViews();
}
Related
Problem
I have an existing .NET Framework 4.x Web API that uses OWIN to handle token requests, create and issue tokens and validate them.
The Web API project is being migrated to .NET 6.
As far as I'm aware .NET 6 does not include any functionality that can create tokens, so a third party solution is required. See https://developer.okta.com/blog/2018/03/23/token-authentication-aspnetcore-complete-guide#generate-tokens-for-authentication-in-aspnet-core for more details.
I need a code solution to this problem not an OAuth cloud provider solution.
Possible solution 1
Firstly I looked into IdentityServer 6 from Duende but the licensing costs were prohibitive, even though we have a single Web API to secure we allow each of our clients to generate up to 5 unique ClientId/ClientSecret combinations for their use to access the API.
We currently have around 200+ unique ClientId/ClientSecret combinations that can access our API.
To support this number of clients we would have needed to purchase the Enterprise edition of IdentityServer 6 which is currently $12,000 USD per year.
Possible solution 2
One of my colleagues' suggested using OpenIddict 3.0
From colleague:
"I found AspNet.Security.OpenIdConnect.Server which appears similar to how we currently provide OAuth, it's been merged into OpenIddict 3.0. Apparently DegradedMode allows us to do our own token validation like in the current OWIN provider."
I have created a POC prototype using OpenIddict 3.0 with DegradedMode enabled.
My concern is that because I've enabled DegradedMode that its not down to me to ensure that I've done everything right as I've disabled all of the out of the box goodness.
My question is, looking at the existing implementation details below, do I need to enable DegradedMode in OpenIddict 3.0 in order to have the same functionality as OWIN gives us?
Current .NET Framework 4.x Web API using OWIN implementation details
****************************************
Request New Token
****************************************
ApplicationOAuthProvider.cs => ValidateClientAuthentication(...)
=> GrantClientCredentials(...)
=> GetClaimsIdentities(...)
=> CreateProperties(...)
=> TokenEndpoint(...)
AccessTokenProvider.cs => Create(...)
RefreshTokenProvider.cs => Create(...) (no-ops as AllowRefresh is false)
****************************************
Send API request with Bearer token
****************************************
MyAppOAuthBearerAuthenticationProvider.cs => RequestToken(...)
AccessTokenProvider.cs => Receive...)
Web API
Startup.Auth.cs
public partial class Startup
{
public void ConfigureAuth(IAppBuilder app)
{
// Configure the application for OAuth based flow
var oauthOptions = new OAuthAuthorizationServerOptions
{
TokenEndpointPath = new PathString("/oauth/token"),
Provider = new ApplicationOAuthProvider(),
AuthorizeEndpointPath = new PathString("/oauth/authorize"),
AccessTokenExpireTimeSpan = TimeSpan.FromDays(14),
AllowInsecureHttp = true,
AccessTokenProvider = new AccessTokenProvider(),
RefreshTokenProvider = new RefreshTokenProvider()
};
// Enable the application to use bearer tokens to authenticate users
app.UseOAuthAuthorizationServer(oauthOptions);
app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions
{
Provider = new MyAppOAuthBearerAuthenticationProvider("/oauth/"),
AccessTokenProvider = new AccessTokenProvider()
});
}
}
ApplicationOAuthProvider.cs
public class ApplicationOAuthProvider : OAuthAuthorizationServerProvider
{
/// <summary>
/// grant_type=client_credentials
/// </summary>
public override async Task GrantClientCredentials(OAuthGrantClientCredentialsContext context)
{
var partner = context.OwinContext.Get<Partner>(OwinKeys.Partner);
Account account = null;
var accountScopes = context.Scope.Where(s => s.StartsWith("account:")).ToList();
if (accountScopes.Count > 1)
{
// Tokens cannot be scoped to multiple accounts.
context.Rejected();
context.SetError("invalid_grant", "Only one account scope can be provided");
return;
}
if (accountScopes.Count == 1)
{
var accountId = accountScopes[0].Substring("account:".Length);
account = await DependencyResolver.Current.GetService<IAccountService>().FindAsync(partner.Id, accountId);
if (account?.Status != AccountStatus.Active)
{
context.Rejected();
context.SetError("invalid_scope", "Account not found.");
return;
}
context.OwinContext.Set(OwinKeys.Account, account);
}
var (oAuthIdentity, cookiesIdentity) = await GetClaimIdentities(partner, account, null, null).ConfigureAwait(false);
var properties = CreateProperties(context.ClientId, null);
var ticket = new AuthenticationTicket(oAuthIdentity, properties);
// Disable refresh token for client_credentials.
// 'A refresh token SHOULD NOT be included.' https://tools.ietf.org/html/rfc6749#section-4.4.3
properties.AllowRefresh = false;
context.Validated(ticket);
context.Request.Context.Authentication.SignIn(properties, cookiesIdentity);
}
public override Task TokenEndpoint(OAuthTokenEndpointContext context)
{
foreach (var property in context.Properties.Dictionary)
{
context.AdditionalResponseParameters.Add(property.Key, property.Value);
}
return Task.FromResult<object>(null);
}
/// <summary>
/// Validate that the request is using valid OAuth ClientId.
/// </summary>
public override async Task ValidateClientAuthentication(OAuthValidateClientAuthenticationContext context)
{
if (!context.TryGetBasicCredentials(out var clientId, out var clientSecret) && !context.TryGetFormCredentials(out clientId, out clientSecret))
{
context.Rejected();
context.SetError("invalid_client", "Client credentials could not be retrieved through the Authorization header.");
return;
}
var partnerService = DependencyResolver.Current.GetService<IPartnerService>();
var partnerOAuthClient = await partnerService.GetPartnerOAuthClientByClientIdAsync(clientId).ConfigureAwait(false);
if (partnerOAuthClient == null || (partnerOAuthClient.ClientSecret != null && partnerOAuthClient.ClientSecret != clientSecret))
{
// Client could not be validated.
context.Rejected();
context.SetError("invalid_client", "Client credentials are invalid.");
return;
}
context.OwinContext.Set(OwinKeys.Partner, partnerOAuthClient.Partner);
// Client has been verified.
context.Validated(clientId);
}
private AuthenticationProperties CreateProperties(string clientId, string username)
{
var data = new Dictionary<string, string>
{
{ "clientId", clientId }
};
if (!string.IsNullOrWhiteSpace(username))
{
data.Add("userName", username);
}
return new AuthenticationProperties(data);
}
/// <summary>
/// Gets the OAuth and Cookie claims identities.
/// </summary>
/// <param name="partner">Partner the token is for.</param>
/// <param name="account">Account the token is for, null if not account restricted token.</param>
/// <param name="user">User the token is for, if using password grant.</param>
/// <param name="userManager">ApplicationUserManager to generate ClaimsIdentity for user, only required for password grant.</param>
private Tuple<ClaimsIdentity, ClaimsIdentity> GetClaimIdentities(Partner partner, Account account)
{
ClaimsIdentity oAuthIdentity = new ClaimsIdentity(OAuthDefaults.AuthenticationType);
ClaimsIdentity cookiesIdentity = new ClaimsIdentity(CookieAuthenticationDefaults.AuthenticationType);
oAuthIdentity.AddClaim(new Claim("http://myapp.com/claims/partnerid", partner.Id.ToString(), ClaimValueTypes.Integer));
cookiesIdentity.AddClaim(new Claim("http://myapp.com/claims/partnerid", partner.Id.ToString(), ClaimValueTypes.Integer));
oAuthIdentity.AddClaim(new Claim(ClaimTypes.Role, IdentityRoleNames.User));
cookiesIdentity.AddClaim(new Claim(ClaimTypes.Role, IdentityRoleNames.User));
if (account == null)
{
oAuthIdentity.AddClaim(new Claim(ClaimTypes.Role, "Partner"));
cookiesIdentity.AddClaim(new Claim(ClaimTypes.Role, "Partner"));
}
else
{
oAuthIdentity.AddClaim(new Claim(ClaimTypes.Role, "Account"));
cookiesIdentity.AddClaim(new Claim(ClaimTypes.Role, "Account"));
oAuthIdentity.AddClaim(new Claim(ClaimTypes.Sid, account.Id.ToString()));
cookiesIdentity.AddClaim(new Claim(ClaimTypes.Sid, account.Id.ToString()));
}
return Tuple.Create(oAuthIdentity, cookiesIdentity);
}
}
AccessTokenProvider.cs
public class AccessTokenProvider : AuthenticationTokenProvider
{
public override void Create(AuthenticationTokenCreateContext context)
{
Guid? accountId = null;
var accessTokenService = DependencyResolver.Current.GetService<IAccessTokenService>();
AccessTokenScope scope = AccessTokenScope.None;
if (context.Ticket.Identity.HasClaim(c => c.Type == ClaimTypes.Role && c.Value == "Account"))
{
scope = AccessTokenScope.Account;
accountId = Guid.Parse(context.Ticket.Identity.Claims.First(c => c.Type == ClaimTypes.Sid).Value);
}
else if (context.Ticket.Identity.HasClaim(c => c.Type == ClaimTypes.Role && c.Value == "Partner"))
scope = AccessTokenScope.Partner;
if (scope == AccessTokenScope.None)
throw new ArgumentNullException(nameof(AccessTokenScope));
context.SetToken(Guid.NewGuid().ToString("n") + Guid.NewGuid().ToString("n"));
var accessTokenHash = GetTokenHash(context.Token);
context.OwinContext.Set(OwinKeys.OAuthAccessTokenHash, accessTokenHash);
accessTokenService.Insert(new AccessToken
{
TokenHash = accessTokenHash,
Ticket = context.SerializeTicket(),
ExpiresUtc = context.Ticket.Properties.ExpiresUtc.Value.UtcDateTime,
ClientId = context.Ticket.Properties.Dictionary["clientId"],
UserId = context.Ticket.Identity.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier)?.Value,
PartnerId = int.Parse(context.Ticket.Identity.Claims.First(c => c.Type == "http://myapp.com/claims/partnerid").Value),
Scope = scope,
AccountId = accountId
});
}
public override void Receive(AuthenticationTokenReceiveContext context)
{
var accessTokenService = DependencyResolver.Current.GetService<IAccessTokenService>();
var accessToken = accessTokenService.Find(GetTokenHash(context.Token));
if (accessToken != null)
context.DeserializeTicket(accessToken.Ticket);
}
public static string GetTokenHash(string token)
{
var sha = new SHA256Managed();
var hash = sha.ComputeHash(Encoding.UTF8.GetBytes(token));
for (var i = 0; i < 9999; i++)
hash = sha.ComputeHash(hash);
return Convert.ToBase64String(hash);
}
}
RefreshTokenProvider.cs
public class RefreshTokenProvider : AuthenticationTokenProvider
{
public override void Create(AuthenticationTokenCreateContext context)
{
if (context.Ticket.Properties.AllowRefresh == false)
return;
var refreshTokenService = DependencyResolver.Current.GetService<IRefreshTokenService>();
context.SetToken(Guid.NewGuid().ToString("n") + Guid.NewGuid().ToString("n"));
string key = context.Token;
context.Ticket.Properties.ExpiresUtc = DateTimeOffset.MaxValue;
string value = context.SerializeTicket();
RefreshToken refreshToken = new RefreshToken
{
Key = key,
Value = value,
AccessTokenHash = context.OwinContext.Get<string>(OwinKeys.OAuthAccessTokenHash)
};
refreshTokenService.InsertRefreshToken(refreshToken);
}
public override void Receive(AuthenticationTokenReceiveContext context)
{
var refreshTokenService = DependencyResolver.Current.GetService<IRefreshTokenService>();
var accessTokenService = DependencyResolver.Current.GetService<IAccessTokenService>();
var refreshToken = refreshTokenService.GetRefreshTokenByKey(context.Token);
if (refreshToken != null)
{
context.DeserializeTicket(refreshToken.Value);
accessTokenService.Delete(refreshToken.AccessTokenHash);
refreshTokenService.DeleteRefreshToken(refreshToken);
}
}
}
MyAppOAuthBearerAuthenticationProvider.cs
public class MyAppOAuthBearerAuthenticationProvider : OAuthBearerAuthenticationProvider
{
private readonly string _oauthRequestPath;
public MyAppOAuthBearerAuthenticationProvider(string oauthRequestPath)
{
_oauthRequestPath = oauthRequestPath;
}
public override async Task RequestToken(OAuthRequestTokenContext context)
{
if (context.Token != null && !context.Request.Path.Value.StartsWith(_oauthRequestPath))
{
// Need to check the token is still valid.
var accessTokenService = DependencyResolver.Current.GetService<IAccessTokenService>();
var accessToken = accessTokenService.Find(AccessTokenProvider.GetTokenHash(context.Token));
if (accessToken == null)
{
context.Token = null;
return;
}
// Check for expired token.
if (accessToken.ExpiresUtc < DateTime.UtcNow)
{
context.Token = null;
accessTokenService.Delete(accessToken);
return;
}
var revokeToken = false;
Partner partner = null;
string externalAccountId = null;
Guid? accountId = null;
if (accessToken.Scope == AccessTokenScope.Partner && context.Request.Headers.ContainsKey(MyAppWebParameters.APIAccountHeaderName))
{
if (string.IsNullOrWhiteSpace(context.Request.Headers[MyAppWebParameters.APIAccountHeaderName]))
{
context.Token = null;
return;
}
externalAccountId = context.Request.Headers[MyAppWebParameters.APIAccountHeaderName]; // Set the account ID from the header.
}
else if (accessToken.Scope == AccessTokenScope.Account)
{
accountId = accessToken.AccountId; // Set the account ID from the token.
}
var scope = externalAccountId != null || accountId != null ? AccessTokenScope.Account : accessToken.Scope;
switch (scope)
{
case AccessTokenScope.Account:
// Check the account still exists.
var accountService = DependencyResolver.Current.GetService<IAccountService>();
var account = externalAccountId != null ? await accountService.FindAsync(accessToken.PartnerId, externalAccountId) :
accountId != null ? await accountService.FindAsync(accessToken.PartnerId, accountId.Value) : null;
if (account?.Status == AccountStatus.DeleteScheduled)
{
// Account is scheduled to be deleted, don't want to revoke the token yet incase delete was mistake and cancelled.
context.Token = null;
return;
}
partner = account?.Partner;
revokeToken = account == null || account.Partner?.OAuthClients?.Any(s => s.Id == accessToken.ClientId) != true ||
account.Status != AccountStatus.Active || account.Partner?.Id != accessToken.PartnerId;
if (revokeToken && accessToken.Scope == AccessTokenScope.Partner)
{
// Don't revoke partner tokens if account not found or for different partner.
context.Token = null;
return;
}
if (!revokeToken)
{
context.OwinContext.Set(OwinKeys.Account, account);
context.OwinContext.Set(OwinKeys.Partner, account.Partner);
}
break;
case AccessTokenScope.Partner:
// Check that the partner client id hasn't changed.
var partnerService = DependencyResolver.Current.GetService<IPartnerService>();
partner = (await partnerService.GetPartnerOAuthClientByClientIdAsync(accessToken.ClientId))?.Partner;
revokeToken = partner?.Id != accessToken.PartnerId;
if (!revokeToken)
context.OwinContext.Set(OwinKeys.Partner, partner);
break;
case AccessTokenScope.None:
default:
break;
}
if (partner?.PartnerStatus != PartnerStatus.Active || partner?.TrialExpired == true)
throw new UnauthorizedAccessException();
if (revokeToken)
{
context.Token = null;
accessTokenService.Delete(accessToken);
return;
}
}
await base.RequestToken(context);
}
}
Current POC prototype OpenIddict implementation details
Program.cs
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddControllers();
var migrationsAssembly = typeof(Program).Assembly.GetName().Name;
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddDbContext<OAuthDbContext>(options =>
{
// Configure the context to use Microsoft SQL Server.
options.UseMySql(connectionString,
new MySqlServerVersion(new Version(CyclrParameters.MySqlMajorVersion,
CyclrParameters.MySqlMinorVersion,
CyclrParameters.MySqlBuildVersion)),
mySql => mySql.MigrationsAssembly(migrationsAssembly));
// Register the entity sets needed by OpenIddict but use the specified entities instead of the default ones.
options.UseOpenIddict<OAuthApplication, OAuthAuthorization, OAuthScope, OAuthToken, string>();
});
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
builder.Services.AddAuthentication("cyclr")
.AddCookie();
builder.Services.AddAuthorization(options =>
{
options.AddPolicy(AuthorizationPolicies.UserPolicy, policy =>
{
policy.RequireAuthenticatedUser();
policy.RequireRole(AuthorizationRoles.UserRole);
});
options.AddPolicy(AuthorizationPolicies.PartnerPolicy, policy =>
{
policy.RequireAuthenticatedUser();
policy.RequireRole(AuthorizationRoles.PartnerRole);
});
options.AddPolicy(AuthorizationPolicies.AccountPolicy, policy =>
{
policy.RequireAuthenticatedUser();
policy.RequireRole(AuthorizationRoles.AccountRole);
});
});
builder.Services
.AddOpenIddict()
// Register the OpenIddict core components.
.AddCore(options =>
{
// Configure OpenIddict to use the Entity Framework Core stores and models.
// Note: call ReplaceDefaultEntities() to replace the default OpenIddict entities.
options.UseEntityFrameworkCore()
.UseDbContext<OAuthDbContext>()
.ReplaceDefaultEntities<OAuthApplication, OAuthAuthorization, OAuthScope, OAuthToken, string>();
options.AddApplicationStore<OAuthApplicationStore>();
options.ReplaceApplicationManager<OAuthApplicationManager>();
})
// Register the OpenIddict server components.
.AddServer(options =>
{
//options.DisableAccessTokenEncryption(); //uncomment this line if you wish to view the JWT payload in https://jwt.io/
options.EnableDegradedMode();
options.DisableScopeValidation();
// Enable the token endpoint.
options.SetTokenEndpointUris(CommonParameters.TokenEndPoint);
// Enable the client credentials flow.
options.AllowClientCredentialsFlow();
options.RegisterScopes("account");
// Register the signing and encryption credentials.
options.AddDevelopmentEncryptionCertificate()
.AddDevelopmentSigningCertificate();
// Register the ASP.NET Core host and configure the ASP.NET Core-specific options.
options.UseAspNetCore()
.EnableTokenEndpointPassthrough();
// Custom Token Request Validation
options.AddEventHandler<ValidateTokenRequestContext>(builder =>
builder.UseScopedHandler<ValidateTokenRequestHandler>());
options.AddEventHandler<HandleTokenRequestContext>(builder =>
builder.UseInlineHandler(context =>
{
var scopes = context.Request.GetScopes();
Console.WriteLine("HandleTokenRequestContext");
return default;
}));
options.AddEventHandler<ValidateAuthorizationRequestContext>(builder =>
builder.UseInlineHandler(context =>
{
Console.WriteLine("ValidateAuthorizationRequestContext");
return default;
}));
//Custom Handle Authorization Request
options.AddEventHandler<HandleAuthorizationRequestContext>(builder =>
builder.UseInlineHandler(context =>
{
//context.Reject(error: "Invalid Client", description: "The specified 'client_id' doesn't match a registered application.");
Console.WriteLine("HandleAuthorizationRequestContext");
return default;
}));
})
// Register the OpenIddict validation components.
.AddValidation(options =>
{
// Import the configuration from the local OpenIddict server instance.
options.UseLocalServer();
// Register the ASP.NET Core host.
options.UseAspNetCore();
});
// Register the worker responsible for seeding the database.
// Note: in a real world application, this step should be part of a setup script.
builder.Services.AddHostedService<Worker>();
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
app.UseHttpsRedirection();
app.UseAuthentication();
app.UseAuthorization();
app.MapControllers();
app.Run();
ValidateTokenRequestHandler.cs
public class ValidateTokenRequestHandler : IOpenIddictServerHandler<ValidateTokenRequestContext>
{
private readonly IOpenIddictApplicationManager _applicationManager;
private readonly IAccountService _accountService;
public ValidateTokenRequestHandler(IOpenIddictApplicationManager applicationManager,
IAccountService accountService)
{
_applicationManager = applicationManager;
_accountService = accountService;
}
public async ValueTask HandleAsync(ValidateTokenRequestContext context)
{
var application = await _applicationManager.FindByClientIdAsync(CommonParameters.ClientId);
if (application is not null && application is OAuthApplication oauthApplication)
{
//The ClientSecret is hashed (using PBKDF with HMAC-SHA256) before it is stored in the database.
//You can't retrieve the original secret once it's stored in the database, for obvious security reasons.
//See: https://github.com/openiddict/openiddict-core/issues/418#issuecomment-315090786
//The best option to verify that the ClientSecret is correct is to use the same Third Party CryptoHelper to verify
//that the hash and password are a cryptographic match.
var isMatch = false;
try
{
isMatch = CryptoHelper.Crypto.VerifyHashedPassword(oauthApplication.ClientSecret, context.ClientSecret);
}
catch
{
isMatch = false;
}
if (!isMatch)
{
context.Reject(error: "invalid_grant", description: "Client credentials are invalid.");
return;
}
var partnerId = oauthApplication.PartnerId;
Guid? accountId = null;
const string AccountScopeKey = "account:";
var accountScopes = context.Request.GetScopes().Where(s => s.StartsWith(AccountScopeKey)).ToList();
if (accountScopes.Count > 1)
{
// Tokens cannot be scoped to multiple accounts.
context.Reject(error: "invalid_grant", description: "Only one account scope can be provided.");
return;
}
if (accountScopes.Count == 1)
{
var account = await _accountService.FindAsync(partnerId, accountScopes[0].Substring(AccountScopeKey.Length));
if (account?.Status != AccountStatus.Active)
{
context.Reject(error: "invalid_scope", description: "Account not found.");
return;
}
accountId = account?.Id;
if (accountId.HasValue)
{
context.Request.SetParameter("AccountId", accountId.Value.ToString());
}
}
return;
}
context.Reject(error: "invalid_grant", description: "Client credentials are invalid.");
return;
}
}
What I have in my mind when navigating through the application, I want to save the token to the localhost along with role name and I will check if the users have access to a certain link. Is that how it works? with Authgard in Angular 8?. Can you give me some insight of navigating an application with the role from Identity(which is built in from ASP.net core 3.1).
login
// POST api/auth/login
[HttpPost("login")]
public async Task<IActionResult> Post([FromBody]CredentialsViewModel credentials)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var identity = await GetClaimsIdentity(credentials.UserName, credentials.Password);
if (identity == null)
{
//return null;
return BadRequest(Error.AddErrorToModelState("login_failure", "Invalid username or password.", ModelState));
}
var jwt = await Tokens.GenerateJwt(identity, _jwtFactory, credentials.UserName, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented });
return new OkObjectResult(jwt);
}
Generate Token Method
public static async Task<string> GenerateJwt(ClaimsIdentity identity, IJwtFactory jwtFactory, string userName, JwtIssuerOptions jwtOptions, JsonSerializerSettings serializerSettings)
{
var response = new
{
id = identity.Claims.Single(c => c.Type == "id").Value,
//probably here I want to send the role too!!
auth_token = await jwtFactory.GenerateEncodedToken(userName, identity),
expires_in = (int)jwtOptions.ValidFor.TotalSeconds
};
return JsonConvert.SerializeObject(response, serializerSettings);
}
}
You need to add claims information when generating your JWT.
Here`s an example
And another one:
1 part(how to implement JWT), 2 part(about claims here)
I have an MVC site that is using membership providers for authenticating against multiple domains.
I am using SESSION to store the displayName of my user that I then display in my _Layout.cshtml
This all works perfectly on my localhost, but when I deploy my app to VM/Server the SESSION is null and i get Object not set to an instance of an object and the error points to the line in my layout page where i display the full username. This happens after session timeout and user requests a new page and are required to login again.
Here is my Login method:
if (!ModelState.IsValid)
{
return View(model);
}
Session["UserName"] = "Unknown User";
Logger.Instance.Info("Setting username to unknown user");
var msg = string.Empty;
var user = _userSvc.GetLoginUserData(model.Username, out msg);
if (!string.IsNullOrEmpty(msg))
{
Logger.Instance.Info("getting user info but error returned: "+msg);
ModelState.AddModelError("", msg);
return View(model);
}
Logger.Instance.Info("User was found "+user.EMAIL);
foreach (MembershipProvider provider in Membership.Providers)
{
var username = user.LEGACY_USERNAME;
if (provider.Name == "ADENTMembershipProvider") username = user.ENT_USERNAME;
try
{
Logger.Instance.Info("Authenticating user "+username+" to "+provider.Name);
if (provider.ValidateUser(username, model.Password))
{
Session["UserName"] = user.FIRST_NAME + ' ' + user.LAST_NAME;
Logger.Instance.Info("User authenticated " + Session["UserName"]);
var authTicket = new FormsAuthenticationTicket(
1, // version
user.ID.ToString(), // user name
DateTime.Now, // created
DateTime.Now.AddMinutes(2), // expires
false, // persistent?
user.ROLE // can be used to store roles
);
string encryptedTicket = FormsAuthentication.Encrypt(authTicket);
var authCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encryptedTicket);
Response.Cookies.Add(authCookie);
if (returnUrl != null && returnUrl != "/")
{
Logger.Instance.Info("Redirecting user to " + returnUrl);
Response.Redirect(returnUrl);
}
else
{
return RedirectToAction("Index", "Home");
}
}
}
catch (Exception ex)
{
Logger.Instance.Error("Error authenticating user " + username + " to " + provider.Name, ex);
}
}
SynLogger.Instance.Info("User could not be authenticated " );
// User was not authenticated in any of the AD
ModelState.AddModelError("", "Invalid login attempt. The username or password provided is incorrect.");
return View(model);
Here is the line in my layout that is causing the issue when session times out and user re-logs in:
Hello #Html.Raw(Session["UserName"].ToString())
Not sure why it works on my development machine but not when I deploy to server.
Is there another way I can store the username other than SESSION so I can access it my layout page?
I created an ASP.NET WEB API 2.2 project. I used the Windows Identity Foundation based template for individual accounts available in visual studio see it here.
The web client (written in angularJS) uses OAUTH implementation with web browser cookies to store the token and the refresh token. We benefit from the helpful UserManager and RoleManager classes for managing users and their roles.
Everything works fine with OAUTH and the web browser client.
However, for some retro-compatibility concerns with desktop based clients I also need to support Basic authentication. Ideally, I would like the [Authorize], [Authorize(Role = "administrators")] etc. attributes to work with both OAUTH and Basic authentication scheme.
Thus, following the code from LeastPrivilege I created an OWIN BasicAuthenticationMiddleware that inherits from AuthenticationMiddleware.
I came to the following implementation. For the BasicAuthenticationMiddleWare only the Handler has changed compared to the Leastprivilege's code. Actually we use ClaimsIdentity rather than a series of Claim.
class BasicAuthenticationHandler: AuthenticationHandler<BasicAuthenticationOptions>
{
private readonly string _challenge;
public BasicAuthenticationHandler(BasicAuthenticationOptions options)
{
_challenge = "Basic realm=" + options.Realm;
}
protected override async Task<AuthenticationTicket> AuthenticateCoreAsync()
{
var authzValue = Request.Headers.Get("Authorization");
if (string.IsNullOrEmpty(authzValue) || !authzValue.StartsWith("Basic ", StringComparison.OrdinalIgnoreCase))
{
return null;
}
var token = authzValue.Substring("Basic ".Length).Trim();
var claimsIdentity = await TryGetPrincipalFromBasicCredentials(token, Options.CredentialValidationFunction);
if (claimsIdentity == null)
{
return null;
}
else
{
Request.User = new ClaimsPrincipal(claimsIdentity);
return new AuthenticationTicket(claimsIdentity, new AuthenticationProperties());
}
}
protected override Task ApplyResponseChallengeAsync()
{
if (Response.StatusCode == 401)
{
var challenge = Helper.LookupChallenge(Options.AuthenticationType, Options.AuthenticationMode);
if (challenge != null)
{
Response.Headers.AppendValues("WWW-Authenticate", _challenge);
}
}
return Task.FromResult<object>(null);
}
async Task<ClaimsIdentity> TryGetPrincipalFromBasicCredentials(string credentials,
BasicAuthenticationMiddleware.CredentialValidationFunction validate)
{
string pair;
try
{
pair = Encoding.UTF8.GetString(
Convert.FromBase64String(credentials));
}
catch (FormatException)
{
return null;
}
catch (ArgumentException)
{
return null;
}
var ix = pair.IndexOf(':');
if (ix == -1)
{
return null;
}
var username = pair.Substring(0, ix);
var pw = pair.Substring(ix + 1);
return await validate(username, pw);
}
Then in Startup.Auth I declare the following delegate for validating authentication (simply checks if the user exists and if the password is right and generates the associated ClaimsIdentity)
public void ConfigureAuth(IAppBuilder app)
{
app.CreatePerOwinContext(DbContext.Create);
app.CreatePerOwinContext<ApplicationUserManager>(ApplicationUserManager.Create);
Func<string, string, Task<ClaimsIdentity>> validationCallback = (string userName, string password) =>
{
using (DbContext dbContext = new DbContext())
using(UserStore<ApplicationUser> userStore = new UserStore<ApplicationUser>(dbContext))
using(ApplicationUserManager userManager = new ApplicationUserManager(userStore))
{
var user = userManager.FindByName(userName);
if (user == null)
{
return null;
}
bool ok = userManager.CheckPassword(user, password);
if (!ok)
{
return null;
}
ClaimsIdentity claimsIdentity = userManager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie);
return Task.FromResult(claimsIdentity);
}
};
var basicAuthOptions = new BasicAuthenticationOptions("KMailWebManager", new BasicAuthenticationMiddleware.CredentialValidationFunction(validationCallback));
app.UseBasicAuthentication(basicAuthOptions);
// Configure the application for OAuth based flow
PublicClientId = "self";
OAuthOptions = new OAuthAuthorizationServerOptions
{
TokenEndpointPath = new PathString("/Token"),
Provider = new ApplicationOAuthProvider(PublicClientId),
//If the AccessTokenExpireTimeSpan is changed, also change the ExpiresUtc in the RefreshTokenProvider.cs.
AccessTokenExpireTimeSpan = TimeSpan.FromHours(2),
AllowInsecureHttp = true,
RefreshTokenProvider = new RefreshTokenProvider()
};
// Enable the application to use bearer tokens to authenticate users
app.UseOAuthBearerTokens(OAuthOptions);
}
However, even with settings the Request.User in Handler's AuthenticationAsyncCore method the [Authorize] attribute does not work as expected: responding with error 401 unauthorized every time I try to use the Basic Authentication scheme.
Any idea on what is going wrong?
I found out the culprit, in the WebApiConfig.cs file the 'individual user' template inserted the following lines.
//// Web API configuration and services
//// Configure Web API to use only bearer token authentication.
config.SuppressDefaultHostAuthentication();
config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
Thus we also have to register our BasicAuthenticationMiddleware
config.SuppressDefaultHostAuthentication();
config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
config.Filters.Add(new HostAuthenticationFilter(BasicAuthenticationOptions.BasicAuthenticationType));
where BasicAuthenticationType is the constant string "Basic" that is passed to the base constructor of BasicAuthenticationOptions
public class BasicAuthenticationOptions : AuthenticationOptions
{
public const string BasicAuthenticationType = "Basic";
public BasicAuthenticationMiddleware.CredentialValidationFunction CredentialValidationFunction { get; private set; }
public BasicAuthenticationOptions( BasicAuthenticationMiddleware.CredentialValidationFunction validationFunction)
: base(BasicAuthenticationType)
{
CredentialValidationFunction = validationFunction;
}
}
What I have?
I have configured FBA in one of the web applications with out of the box login page having dropdown box to select the either windows or FBA login. Everything is working fine.
What I want?
I want to have a custom login page having text boxes for Username and Password and a login button which will be used for authenticating both Windows and FBA users. To distinguish between the two different logins, I want to handle OnAuthenticate event and check if the user name contains a '\' then assume it is Windows user otherwise, it is FBA user.
This is the code written in OnAuthenticate event handler:
protected void signinControl_Authenticate(object sender, AuthenticateEventArgs e)
{
string fullUserName = signinControl.UserName;
string username = null;
if (fullUserName.Contains("\\")) //Windows user
{
string domain = fullUserName.Substring(0, fullUserName.IndexOf("\\"));
using (PrincipalContext pc = new PrincipalContext(ContextType.Domain, domain))
{
username = fullUserName.Substring(fullUserName.IndexOf("\\") + 1);
e.Authenticated = pc.ValidateCredentials(username, signinControl.Password);
}
}
else //FBA user
{
e.Authenticated = Membership.ValidateUser(fullUserName, signinControl.Password);
}
}
What problem am I facing?
The code above works well for FBA Users. But, when I try to login with a windows user, even though the e.Authenticated is set true after validating, it is throwing this error: "Your login attempt was not successful. Please try again.".
e.Authenticated = pc.ValidateCredentials(username, signinControl.Password);
I believe that, setting e.Authenticated to true should redirect the user from login page to the requested page. Can someone please help me if I have to do anything else to get Windows user signed in?
Update-1:
I used SetAuthCookie() method to set Cookie explicitly, still the same result.
FormsAuthentication.SetAuthCookie(username, true);
you should use the methode below for forms user
SPClaimsUtility.AuthenticateFormsUser(
Context.Request.UrlReferrer,
UserName.Text,
Password.Text);
and the windows part is declared like this:
protected void lbInternalUsers_OnClick(object sender, EventArgs e)
{
try
{
if (null != SPContext.Current && null != SPContext.Current.Site)
{
SPIisSettings iisSettings = SPContext.Current.Site.WebApplication.IisSettings[SPUrlZone.Default];
if (null != iisSettings && iisSettings.UseWindowsClaimsAuthenticationProvider)
{
SPAuthenticationProvider provider = iisSettings.WindowsClaimsAuthenticationProvider;
Redirect(provider);
}
}
}
catch (Exception ex)
{
lblError.Text = ex.Message;
}
}
private void Redirect(SPAuthenticationProvider provider)
{
string comp = HttpContext.Current.Request.Url.GetComponents(UriComponents.Query, UriFormat.SafeUnescaped);
string url = provider.AuthenticationRedirectionUrl.ToString();
if (provider is SPWindowsAuthenticationProvider)
{
comp = EnsureUrl(comp, true);
}
SPUtility.Redirect(url, SPRedirectFlags.Default, this.Context, comp);
}
private string EnsureUrl(string url, bool urlIsQueryStringOnly)
{
if (!url.Contains("ReturnUrl="))
{
if (urlIsQueryStringOnly)
{
url = url + (string.IsNullOrEmpty(url) ? "" : "&");
}
else
{
url = url + ((url.IndexOf('?') == -1) ? "?" : "&");
}
url = url + "ReturnUrl=";
}
return url;
}
as detailed here in the reference