First Commit

Helpers/ADS.Helpers.Middleware/InternalUser/IInternalUserContextAccessor.cs

@@ -0,0 +1,6 @@
+namespace ADS.Helpers.Middleware.InternalUser;
+
+public interface IInternalUserContextAccessor
+{
+    InternalUserContext? Current { get; set; }
+}

Helpers/ADS.Helpers.Middleware/InternalUser/InternalAuthorizeAttribute.cs

@@ -0,0 +1,26 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace ADS.Helpers.Middleware.InternalUser;
+
+public class InternalAuthorizeAttribute : Attribute, IAuthorizationFilter
+{
+    public void OnAuthorization(AuthorizationFilterContext context)
+    {
+        var allowAnonymous = context.ActionDescriptor.EndpointMetadata
+            .OfType<AllowAnonymousAttribute>()
+            .Any();
+
+        if (allowAnonymous)
+            return;
+
+        var accessor = context.HttpContext.RequestServices
+            .GetService(typeof(IInternalUserContextAccessor)) as IInternalUserContextAccessor;
+
+        if (accessor?.Current == null)
+        {
+            context.Result = new UnauthorizedResult();
+        }
+    }
+}

Helpers/ADS.Helpers.Middleware/InternalUser/InternalUserContext.cs

@@ -0,0 +1,8 @@
+namespace ADS.Helpers.Middleware.InternalUser;
+
+public class InternalUserContext
+{
+    public int CveUser { get; set; }
+    public int CveEmpresa { get; set; }
+    public int CveCliente { get; set; }
+}

Helpers/ADS.Helpers.Middleware/InternalUser/InternalUserContextAccessor.cs

@@ -0,0 +1,6 @@
+namespace ADS.Helpers.Middleware.InternalUser;
+
+public class InternalUserContextAccessor : IInternalUserContextAccessor
+{
+    public InternalUserContext? Current { get; set; }
+}

Helpers/ADS.Helpers.Middleware/InternalUser/InternalUserContextMiddleware.cs

@@ -0,0 +1,67 @@
+using System.Security.Cryptography;
+using System.Text;
+using ADS.Helpers.MultiTenant.InternalRouting;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Configuration;
+
+namespace ADS.Helpers.Middleware.InternalUser;
+
+public class InternalUserContextMiddleware
+{
+    private readonly RequestDelegate _next;
+
+    public InternalUserContextMiddleware(RequestDelegate next)
+    {
+        _next = next;
+    }
+
+    public async Task InvokeAsync(
+        HttpContext context,
+        IInternalUserContextAccessor accessor,
+        IConfiguration configuration)
+    {
+        var cveUserHeader = context.Request.Headers[InternalHeaders.CveUser].FirstOrDefault();
+        var cveEmpresaHeader = context.Request.Headers[InternalHeaders.CveEmpresa].FirstOrDefault();
+        var cveClienteHeader = context.Request.Headers[InternalHeaders.CveCliente].FirstOrDefault();
+        var timestampHeader = context.Request.Headers[InternalHeaders.Timestamp].FirstOrDefault();
+        var signatureHeader = context.Request.Headers[InternalHeaders.User_Signature].FirstOrDefault();
+
+        if (!string.IsNullOrWhiteSpace(cveUserHeader) &&
+            !string.IsNullOrWhiteSpace(cveEmpresaHeader) &&
+            !string.IsNullOrWhiteSpace(cveClienteHeader) &&
+            !string.IsNullOrWhiteSpace(timestampHeader) &&
+            !string.IsNullOrWhiteSpace(signatureHeader))
+        {
+            var secret = configuration["InternalRouting:SharedSecret"];
+
+            if (string.IsNullOrWhiteSpace(secret))
+                throw new InvalidOperationException("InternalRouting:SharedSecret no está configurado.");
+
+            var raw = $"{cveUserHeader}|{cveEmpresaHeader}|{cveClienteHeader}|{timestampHeader}";
+            var expectedSignature = ComputeHmacSha256(raw, secret);
+
+            if (signatureHeader == expectedSignature)
+            {
+                accessor.Current = new InternalUserContext
+                {
+                    CveUser = int.Parse(cveUserHeader),
+                    CveEmpresa = int.Parse(cveEmpresaHeader),
+                    CveCliente = int.Parse(cveClienteHeader)
+                };
+            }
+        }
+
+        await _next(context);
+    }
+
+    private static string ComputeHmacSha256(string value, string secret)
+    {
+        var key = Encoding.UTF8.GetBytes(secret);
+        var bytes = Encoding.UTF8.GetBytes(value);
+
+        using var hmac = new HMACSHA256(key);
+        var hash = hmac.ComputeHash(bytes);
+
+        return Convert.ToBase64String(hash);
+    }
+}