👁 Image
Hexalith.Security.WebServer 2.14.9

Hexalith.Security

Overview

Hexalith.Security is a comprehensive security framework for .NET applications providing authentication, authorization, and identity management capabilities. Built with modern C# and Blazor, it offers a robust approach to implementing security in web applications, API servers, and microservices.

Build Status

👁 License: MIT
👁 Discord

👁 Codacy Badge
👁 Quality Gate Status
👁 Security Rating
👁 Maintainability Rating
👁 Code Smells
👁 Lines of Code
👁 Technical Debt
👁 Reliability Rating
👁 Duplicated Lines (%)
👁 Vulnerabilities
👁 Bugs

👁 Build status
👁 NuGet
👁 Latest

Architecture

The Hexalith.Security project follows a modular architecture with clear separation of concerns:

Core Components

• Abstractions: Defines interfaces, models, and contracts for security features
• Application: Business logic and services for security functionality
• Infrastructure: Implementation of data access and external service integration
• Presentation: UI components and pages for user interactions
• Modules: Integration modules for different application types (WebApp, WebServer, ApiServer)

Integration with Hexalith Framework

The security module integrates with:

• Hexalith.IdentityStores: For identity storage and management
• Hexalith.Application: For application module integration
• Hexalith.Infrastructure.DaprRuntime: For distributed application runtime support

Modules

WebApp Module (HexalithSecurityWebAppModule)

Client-side authentication and authorization for Blazor WebAssembly applications:

// Program.cs
var builder = WebAssemblyHostBuilder.CreateDefault(args);
// ...
HexalithSecurityWebAppModule.AddServices(builder.Services, builder.Configuration);

WebServer Module (HexalithSecurityWebServerModule)

Server-side authentication and authorization:

// Program.cs
var builder = WebApplication.CreateBuilder(args);
// ...
builder.Services.AddModule<HexalithSecurityWebServerModule>(builder.Configuration);

var app = builder.Build();
// ...
app.UseModule<HexalithSecurityWebServerModule>();
app.UseSecurity<HexalithSecurityWebServerModule>();

ApiServer Module (HexalithSecurityApiServerModule)

Security for API-focused applications:

// Program.cs
var builder = WebApplication.CreateBuilder(args);
// ...
builder.Services.AddModule<HexalithSecurityApiServerModule>(builder.Configuration);

Security Features

• Authentication: ASP.NET Core Authentication, multiple schemes, Dapr-based authentication
• Authorization: Policy-based, role-based access control
• Predefined Security Roles: Owner, Contributor, Reader
• Predefined Security Policies: For respective roles

Repository Structure

The repository is organized as follows:

• Is the source code directory of your project.
• Is the source code directory where you will add your Nuget package projects.
• Contains example implementations of your projects.
• Is the source code directory where you will add your Docker container projects.
• Is the source code directory where you will add your Aspire project.
• Contains test projects for your packages.
• Contains shared build configurations and tools.

Getting Started

Prerequisites

• Hexalith.Builds
• Hexalith.IdentityStores
• .NET 8 SDK or later
• PowerShell 7 or later
• Git

Installation

Add the Hexalith.Security NuGet package to your project:

dotnet add package Hexalith.Security

Configuration

Configure security settings in your appsettings.json:

{
 "Security": {
 "Disabled": false
 }
}

Examples

Protecting a Blazor Page

@page "/secure-page"
@attribute [Authorize]
<h1>Secure Page</h1>

<p>This page is only accessible to authenticated users.</p>

Using Role-Based Authorization

@page "/admin-page"
@attribute [Authorize(Roles = SecurityRoles.Owner)]
<h1>Admin Page</h1>

<p>This page is only accessible to users with the Owner role.</p>

Using Policy-Based Authorization

@page "/contributor-page"
@attribute [Authorize(Policy = SecurityPolicies.Contributors)]
<h1>Contributors Page</h1>

<p>This page is only accessible to users who can contribute.</p>

Best Practices

1. Use predefined roles and policies whenever possible
2. Implement the principle of least privilege by assigning minimum required permissions
3. Validate authorization at both UI and API levels
4. Configure proper authentication mechanisms based on your application type
5. Use cascading authentication state in Blazor applications for optimal performance

License

This project is licensed under the MIT License - see the file for details.

Support and Community

For support, please open an issue on the GitHub repository.

Join our Discord community: Hexalith Discord