Need help with Security.Identity?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

NetDevPack
149 Stars 20 Forks MIT License 31 Commits 2 Opened issues

Description

.NET DevPack Identity is a set of common implementations to help you implementing Identity, Jwt, claims validation and another facilities

Services available

!
?

Need anything else?

Contributors list

.NET DevPack

What is the .NET DevPack.Identity?

.NET DevPack Identity is a set of common implementations to help you implementing ASP.NET Identity, JWT, claims validation and another facilities

Codacy Badge Build status .NET Core License

Give a Star! :star:

If you liked the project or if NetDevPack helped you, please give a star ;)

Get Started

| Package | Version | Popularity | | ------- | ----- | ----- | |

NetDevPack.Identity
| NuGet | Nuget |

.NET DevPack.Identity can be installed in your ASP.NET Core application using the Nuget package manager or the

dotnet
CLI.
dotnet add package NetDevPack.Identity

If you want to use our IdentityDbContext (ASP.NET Identity standard) you will need to create the Identity tables. Set your connection string in the

appsettings.json
and follow the next steps:

Add the IdentityDbContext configuration in your

startup.cs
:
services.AddIdentityEntityFrameworkContextConfiguration(options => 
    options.UseSqlServer(configuration.GetConnectionString("DefaultConnection"), 
    b=>b.MigrationsAssembly("AspNetCore.Jwt.Sample")));

Note: You must inform the namespace to avoid migration errors

Note: You must install the

Microsoft.EntityFrameworkCore.SqlServer
or another provider like
Npgsql.EntityFrameworkCore.PostgreSQL
package to have support from your database. Find the package for your database here

Add the Identity configuration in

ConfigureServices
method of your
startup.cs
:
services.AddIdentityConfiguration();

Note: This extension returns an IdentityBuilder to allow you extending the configuration

Add the Identity configuration in

Configure
method of your
startup.cs
:
app.UseAuthConfiguration();

Note: This method need to be set between

app.UseRouting()
and
app.UseEndpoints()

Run the command to generate the migration files:

dotnet ef migrations add Initial --context NetDevPackAppDbContext --project /.csproj

Run the command to generate the database:

dotnet ef database update --context NetDevPackAppDbContext --project /.csproj

Note: If are you using your own

IdentityDbContext
you must change the
NetDevPackAppDbContext
value to your context class name in the commands above.

After execute this steps you will be all set to use the Identity in your Application.

Configuring JWT

If you want to generate JSON Web Tokens in your application you need to add the JWT configuration in

ConfigureServices
method of your
startup.cs
csharp
services.AddJwtConfiguration(Configuration, "AppSettings");

Note: If you don't inform the configuration name the value adopted will be AppJwtSettings

Set your

appsettings.json
file with this values:
"AppSettings": {
    "SecretKey": "MYSECRETSUPERSECRET",
    "Expiration": 2,
    "Issuer": "SampleApp",
    "Audience": "https://localhost"
}

|Key|Meaning| |--|--| |SecretKey | Is your key to build JWT. This value need to be stored in a safe place in the production way | |Expiration| Expiration time in hours | |Issuer| The name of the JWT issuer | |Audience| The domain that the JWT will be valid. Can be a string collection |

Generating JWT

You will need to set some dependencies in your Authentication Controller:

private readonly SignInManager _signInManager;
private readonly UserManager _userManager;
private readonly AppJwtSettings _appJwtSettings;

public AuthController(SignInManager signInManager, UserManager userManager, IOptions appJwtSettings) { _signInManager = signInManager; _userManager = userManager; _appJwtSettings = appJwtSettings.Value; }

Note: The AppJwtSettings is our dependency and is configured internally during JWT setup (in

startup.cs
file). You just need to inject it in your controller.

Note: The SignInManager and UserManager classes is native from Identity and provided in NetDevPack.Identity. You just need to inject it in your controller.

After user register or login process you can generate a JWT to respond the request. Use our implementation, you just need inform the user email and the dependencies injected in your controller:

return new JwtBuilder()
    .WithUserManager(_userManager)
    .WithJwtSettings(_appJwtSettings)
    .WithEmail(email)
    .BuildToken();

Note: This builder can return a single string with JWT or a complex object

UserResponse
if you want return more data than a single JWT string.

Adding Claims to your JWT

You can call more methods in

JwtBuilder
to provide more information about the user:
return new JwtBuilder()
    .WithUserManager(_userManager)
    .WithJwtSettings(_appJwtSettings)
    .WithEmail(email)
    .WithJwtClaims()
    .WithUserClaims()
    .WithUserRoles()
    .BuildToken();

|Method|Meaning| |--|--| |WithJwtClaims()| Claims of JWT like

sub
,
jti
,
nbf
and others | |WithUserClaims()| The user claims registered in
AspNetUserClaims
table| |WithUserRoles()| The user roles (as claims) registered in
AspNetUserRoles
table | |BuildToken()| Build and return the JWT as single string |

If you want return your complex object

UserResponse
you need to change the last method to:
return new JwtBuilder()
    .WithUserManager(_userManager)
    .WithJwtSettings(_appJwtSettings)
    .WithEmail(email)
    .WithJwtClaims()
    .WithUserClaims()
    .WithUserRoles()
    .BuildUserResponse() as UserResponse;

Note: The safe cast to

UserResponse
is needed because is a subtype of
UserResponse
.

Examples

Use the sample application to understand how NetDevPack.Identity can be implemented and help you to decrease the complexity of your application and development time.

Compatibility

The NetDevPack.Identity was developed to be implemented in ASP.NET Core 3.1

LTS
applications, in the next versions will be add the 2.1
LTS
support.

About

.NET DevPack.Identity was developed by Eduardo Pires under the MIT license.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.