Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/NetDevPack/Security.Identity
.NET DevPack Identity is a set of common implementations to help you implementing Identity, Jwt, claims validation and another facilities
https://github.com/NetDevPack/Security.Identity
access-control asp-net-core asp-net-identity authentication authorization claims custom-authentication identity json-web-token jwt oauth roles
Last synced: about 1 month ago
JSON representation
.NET DevPack Identity is a set of common implementations to help you implementing Identity, Jwt, claims validation and another facilities
- Host: GitHub
- URL: https://github.com/NetDevPack/Security.Identity
- Owner: NetDevPack
- License: mit
- Created: 2020-06-05T21:31:33.000Z (over 4 years ago)
- Default Branch: master
- Last Pushed: 2024-02-08T01:30:18.000Z (10 months ago)
- Last Synced: 2024-08-02T03:02:39.733Z (4 months ago)
- Topics: access-control, asp-net-core, asp-net-identity, authentication, authorization, claims, custom-authentication, identity, json-web-token, jwt, oauth, roles
- Language: C#
- Size: 233 KB
- Stars: 575
- Watchers: 27
- Forks: 50
- Open Issues: 5
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- Funding: .github/FUNDING.yml
- License: LICENSE
Awesome Lists containing this project
- awesome-reference-tools - Security.Identity
README
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
[](https://www.codacy.com/gh/NetDevPack/NetDevPack.Identity?utm_source=github.com&utm_medium=referral&utm_content=NetDevPack/NetDevPack.Identity&utm_campaign=Badge_Grade)
[](https://ci.appveyor.com/project/EduardoPires/netdevpack-identity)
[](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` | [](https://nuget.org/packages/NetDevPack.Identity) | [](https://nuget.org/packages/NetDevPack.Identity) |
.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`:
```csharp
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](https://docs.microsoft.com/en-us/ef/core/providers/?tabs=dotnet-core-cli)
Add the Identity configuration in `ConfigureServices` method of your `startup.cs`:
```csharp
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`:
```csharp
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)
.AddNetDevPackIdentity();
```
Set your `appsettings.json` file with this values:
```json
"AppJwtSettings": {
"Audience": "MyApplication.Name"
}
```
It's possible to configure some aspects of token
|Key|Meaning|Default
|--|--|---|
|Expiration| Expiration time (in hours) | 1 |
|Issuer| The party that "created" the token and signed it with its private key. Usually the application Url | Get current root Url from `HttpContext` |
|Audience| API's that should accept the token. E.g your application Main name. | NetDevPack |
|RefreshTokenExpiration | Refresh token expiration (In Days) | 30 |
|RefreshTokenType | `OneTime` or `ReUse` | 30 |
|SecretKey `Deprecated` | Is your key to build JWT. **Read notes**| Do not use it |
>**Note:** Now we are using [NetDevPack.Security.Jwt](https://github.com/NetDevPack/Security.Jwt) to generate and Store your keys. It generate a RSA 2048 by default. You can check the project for more info.
### Generating JWT
You will need to set a single dependency in your Authentication Controller:
```csharp
public AuthController(IJwtBuilder jwtBuilder)
{
_jwtBuilder = jwtBuilder;
}
```
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:
```csharp
return _jwtBuilder
.WithEmail(email)
.WithRefreshToken()
.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:
```csharp
return _jwtBuilder
.WithEmail(email)
.WithJwtClaims()
.WithUserClaims()
.WithUserRoles()
.WithRefreshToken()
.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:
```csharp
return _jwtBuilder
.WithEmail(email)
.WithJwtClaims()
.WithUserClaims()
.WithUserRoles()
.WithRefreshToken()
.BuildUserResponse();
```
## Examples
Use the [sample application](https://github.com/NetDevPack/NetDevPack.Identity/tree/master/src/Samples/AspNetCore.Jwt.Sample) 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**. It support all .NET versions since 3.1.
## About
.NET DevPack.Identity was developed by [Eduardo Pires](http://eduardopires.net.br) under the [MIT license](LICENSE).