Role based Authorization in ASP .NET core
What is Authorization?
Authorization verifies whether a user has permission to use specific applications or services. While authentication and authorization are distinct processes, authentication must precede authorization, ensuring the user's identity is confirmed before determining their access rights.
When logging into a system, a user must provide credentials like a username and password to authenticate. Next, the authorization process grants rights. For example, an administrative user can create a document library to add, edit, and delete documents, while a non-administrative user can only read documents in the library.
Types of Authorization:
Simple Authorization
Role-Based Authorization
Claim-Based Authorization
Policy-Based Authorization
I have implemented an example of role-based authorization in .NET.
Step 1: Create one new MVC Web Application with the Authentication type “Individual Account”.
Step 2: Register Identity with DefaultTokenProvider in the program.cs file.
builder.Services.AddIdentity<IdentityUser, IdentityRole>(options => options.SignIn.RequireConfirmedAccount = false)
.AddEntityFrameworkStores<ApplicationDbContext>()
.AddDefaultTokenProviders();
For better understanding, I have added one page to add a new role.
Create a new method in the controller and add the following code.
[HttpGet]
public IActionResult Admin()
{
return View();
}
Create a new model Role.cs.
namespace Authorization.Models
{
public class Role
{
public string RoleName { get; set; }
}
}
Create html page for add role.
@model Role
@{
ViewData["Title"] = "Admin";
}
<h1>Admin</h1>
<div class="row">
<div class="col-md-12">
<form method="post" action="@Url.Action("Admin","Home")">
<div class="form-group">
<label>Role Name</label>
<input type="text" class="form-control" style="width:30%;" asp-for="RoleName" placeholder="Role name" required>
</div>
<br />
<button class="btn btn-success" type="submit">Add</button>
</form>
</div>
</div>
I have created a simple page, You can modify the page as per your requirements.
Add a new method in the controller and add the following code. And declare RoleManager<IdentityRole> and inject in the constructor.
private readonly RoleManager<IdentityRole> _roleManager;
public HomeController(RoleManager<IdentityRole> roleManager)
{
_roleManager = roleManager;
}
[HttpPost]
public async Task<IActionResult> Admin(Role role)
{
var result = _roleManager.RoleExistsAsync(role.RoleName).Result;
if (!result)
{
await _roleManager.CreateAsync(new IdentityRole(role.RoleName));
}
return RedirectToAction("Admin");
}
Set a new tab in _Layout.cshtml file to redirect to the Add role page.
<li class="nav-item">
<a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Admin">Add new role</a>
</li>
Run the project and you will see the output.
Here, You can add a new role.
Add a new field in register.cshtml using the following code to assign a role to the user.
<div class="form-floating mb-3">
<select asp-for="Input.Role" class="form-control" aria-required="true">
<option value="">Select role</option>
@foreach (var item in Model.RoleList)
{
<option value="@item.Name">@item.Name</option>
}
</select>
<span asp-validation-for="Input.ConfirmPassword" class="text-danger"></span>
</div>
To get the list of roles you can add the following code in your register.cshtml.cs file. And Add RoleList = _roleManager.Roles in OnPostAsync method also.
public IQueryable<IdentityRole> RoleList { get; set; }
public async Task OnGetAsync(string returnUrl = null)
{
ReturnUrl = returnUrl;
RoleList = _roleManager.Roles;
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
}
Run the project and see the output.
Now, Assign the role to the user, and for that add the following code in OnPostAsync after the user is created.
await _userManager.AddToRoleAsync(user, Input.Role);
Full code of register.cshtml.cs file.
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.AspNetCore.WebUtilities;
using System.ComponentModel.DataAnnotations;
using System.Text;
namespace Authorization.Areas.Identity.Pages.Account
{
public class RegisterModel : PageModel
{
private readonly SignInManager<IdentityUser> _signInManager;
private readonly UserManager<IdentityUser> _userManager;
private readonly RoleManager<IdentityRole> _roleManager;
private readonly IUserStore<IdentityUser> _userStore;
private readonly IUserEmailStore<IdentityUser> _emailStore;
private readonly ILogger<RegisterModel> _logger;
//private readonly IEmailSender _emailSender;
public RegisterModel(
UserManager<IdentityUser> userManager,
IUserStore<IdentityUser> userStore,
SignInManager<IdentityUser> signInManager,
ILogger<RegisterModel> logger,
RoleManager<IdentityRole> roleManager
)
{
_userManager = userManager;
_userStore = userStore;
_emailStore = GetEmailStore();
_signInManager = signInManager;
_roleManager = roleManager;
_logger = logger;
}
[BindProperty]
public InputModel Input { get; set; }
public IQueryable<IdentityRole> RoleList { get; set; }
public string ReturnUrl { get; set; }
public IList<AuthenticationScheme> ExternalLogins { get; set; }
public class InputModel
{
[Required]
[EmailAddress]
[Display(Name = "Email")]
public string Email { get; set; }
[Required]
[Display(Name = "Role")]
public string Role { get; set; }
[Required]
[StringLength(100, ErrorMessage = "The {0} must be at least {2} and at max {1} characters long.", MinimumLength = 6)]
[DataType(DataType.Password)]
[Display(Name = "Password")]
public string Password { get; set; }
[DataType(DataType.Password)]
[Display(Name = "Confirm password")]
[Compare("Password", ErrorMessage = "The password and confirmation password do not match.")]
public string ConfirmPassword { get; set; }
}
public async Task OnGetAsync(string returnUrl = null)
{
ReturnUrl = returnUrl;
RoleList = _roleManager.Roles;
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
}
public async Task<IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl ??= Url.Content("~/");
RoleList = _roleManager.Roles;
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = CreateUser();
await _userStore.SetUserNameAsync(user, Input.Email, CancellationToken.None);
await _emailStore.SetEmailAsync(user, Input.Email, CancellationToken.None);
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
await _userManager.AddToRoleAsync(user, Input.Role);
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl });
}
else
{
await _signInManager.SignInAsync(user, isPersistent: false);
return LocalRedirect(returnUrl);
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return Page();
}
private IdentityUser CreateUser()
{
try
{
return Activator.CreateInstance<IdentityUser>();
}
catch
{
throw new InvalidOperationException($"Can't create an instance of '{nameof(IdentityUser)}'. " +
$"Ensure that '{nameof(IdentityUser)}' is not an abstract class and has a parameterless constructor, or alternatively " +
$"override the register page in /Areas/Identity/Pages/Account/Register.cshtml");
}
}
private IUserEmailStore<IdentityUser> GetEmailStore()
{
if (!_userManager.SupportsUserEmail)
{
throw new NotSupportedException("The default UI requires a user store with email support.");
}
return (IUserEmailStore<IdentityUser>)_userStore;
}
}
}
Now, register one new user and assign a role to them. For example, I have created one user and assign “Admin” to them.
I have added two new methods in the controller and added a default view for that.
[Authorize(Roles = "User")]
public IActionResult UserRoleCheck()
{
return View();
}
[Authorize(Roles = "Admin")]
public IActionResult AdminRoleCheck()
{
return View();
}
I have set the Authorize attribute with the role name on both authorization methods.
Now, I am running the project and clicking on Admin Role, It will open the page of admin because the logged user role and method role both are the same.
If I click on User Role, It will give an Access denied error. Because logged user role and method role both are different.
Here, I am using by default access denied page of identity. You can use custom page also, Just set this path to program.cs file.
builder.Services.ConfigureApplicationCookie(options =>
{
options.AccessDeniedPath = "/Identity/Account/AccessDenied"; // Customize this path as per your application's structure
});
Using this way you will implement the role-based authorization in your application.
Conclusion
By properly implementing authorization in your applications, you can ensure that resources and sensitive information are accessible only to authorized users. Remember to choose the appropriate authorization technique based on your application’s requirements and complexity.
