Guide för härdning av .NET 10-applikationer: Från HTTP-headers till HMAC och Passkeys

// Exempel på modern Nonce-generering i .NET 10/11 middleware
app.Use(async (context, next) =>
{
    // Generera en unik nonce per HTTP-begäran
    var nonce = Convert.ToBase64String(RandomNumberGenerator.GetBytes(16));
    context.Items["CSP-Nonce"] = nonce;

    // 'strict-dynamic' gör att skript som laddas av ett betrott nonce-skript automatiskt godkänns
    var csp = $"default-src 'self'; script-src 'nonce-{nonce}' 'strict-dynamic'; style-src 'self' 'nonce-{nonce}'; connect-src 'self' ws: wss:";

    context.Response.Headers.Append("Content-Security-Policy", csp);
    await next();
});

builder.Services.AddAuthorizationBuilder()
    .SetFallbackPolicy(new AuthorizationPolicyBuilder()
        .RequireAuthenticatedUser()
        .Build());

public static partial class SecurityLogExtensions
{
    [LoggerMessage(EventId = 4004, Level = LogLevel.Critical, 
        Message = "REPLAY ATTACK UTPÅCKT! Nonce redan använd. ClientId: {ClientId}, Nonce: {Nonce}, IP: {RemoteIp}")]
    public static partial void LogReplayAttack(this ILogger logger, string clientId, string nonce, string remoteIp);
}

builder.WebHost.ConfigureKestrel(options =>
{
    options.Limits.MaxRequestBodySize = 10 * 1024 * 1024; // Exempel: Max 10 MB
    options.Limits.RequestHeadersTimeout = TimeSpan.FromSeconds(15);
    options.Limits.KeepAliveTimeout = TimeSpan.FromMinutes(2);
});

builder.Services.AddLogging(logging =>
{
    logging.EnableRedaction();
});

using Microsoft.Extensions.Logging;

namespace MyApi.Security;

public static partial class HmacLogMessages
{
    [LoggerMessage(EventId = 4001, Level = LogLevel.Warning, 
        Message = "HMAC-validering misslyckades: Obligatoriska headers saknas. IP: {RemoteIp}, Path: {Path}")]
    public static partial void LogMissingHeaders(this ILogger logger, string remoteIp, string path);

    [LoggerMessage(EventId = 4002, Level = LogLevel.Warning, 
        Message = "HMAC-validering misslyckades [Steg 1]: Ogiltigt format på tidsstämpel '{Timestamp}'. ClientId: {ClientId}, IP: {RemoteIp}")]
    public static partial void LogInvalidTimestampFormat(this ILogger logger, string timestamp, string clientId, string remoteIp);

    [LoggerMessage(EventId = 4003, Level = LogLevel.Warning, 
        Message = "HMAC-validering misslyckades [Steg 1]: Tidsstämpel utanför godkänt fönster (Time Skew). ClientId: {ClientId}, Tidsdiff: {TimeDiffSeconds}s, IP: {RemoteIp}")]
    public static partial void LogTimeSkewExceeded(this ILogger logger, string clientId, double timeDiffSeconds, string remoteIp);

    [LoggerMessage(EventId = 4004, Level = LogLevel.Critical, 
        Message = "SÄKERHETSVARNING [Steg 2]: Återuppspelningsattack upptäckt (Replay Attack)! Nonce redan använd. ClientId: {ClientId}, Nonce: {Nonce}, IP: {RemoteIp}, Path: {Path}")]
    public static partial void LogReplayAttackDetected(this ILogger logger, string clientId, string nonce, string remoteIp, string path);

    [LoggerMessage(EventId = 4005, Level = LogLevel.Warning, 
        Message = "HMAC-validering misslyckades: Okänd ClientId '{ClientId}'. IP: {RemoteIp}")]
    public static partial void LogUnknownClient(this ILogger logger, string clientId, string remoteIp);

    [LoggerMessage(EventId = 4006, Level = LogLevel.Error, 
        Message = "SÄKERHETSVARNING [Steg 3]: Ogiltig HMAC-signatur (Data ändrad eller fel nyckel). ClientId: {ClientId}, IP: {RemoteIp}, Path: {Path}")]
    public static partial void LogInvalidSignature(this ILogger logger, string clientId, string remoteIp, string path);

    [LoggerMessage(EventId = 4007, Level = LogLevel.Information, 
        Message = "HMAC-validering godkänd. ClientId: {ClientId}, Nonce: {Nonce}")]
    public static partial void LogValidationSuccess(this ILogger logger, string clientId, string nonce);
}

namespace MyApi.Security;

public interface IClientSecretProvider
{
    Task<string?> GetSecretAsync(string clientId);
}

public class InMemoryClientSecretProvider : IClientSecretProvider
{
    private readonly Dictionary<string, string> _secrets = new()
    {
        { "partner_app_a", "KryptografiskHemligNyckelDeladMedKlienten123!" }
    };

    public Task<string?> GetSecretAsync(string clientId)
    {
        _secrets.TryGetValue(clientId, out var secret);
        return Task.FromResult(secret);
    }
}

using System.Security.Cryptography;
using System.Text;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Logging;

namespace MyApi.Security;

public class HmacValidationMiddleware(
    RequestDelegate next,
    ILogger<HmacValidationMiddleware> logger,
    IMemoryCache cache,
    IClientSecretProvider secretProvider)
{
    private static readonly TimeSpan MaxTimeSkew = TimeSpan.FromMinutes(5);

    public async Task InvokeAsync(HttpContext context)
    {
        var remoteIp = context.Connection.RemoteIpAddress?.ToString() ?? "OKÄND";
        var path = context.Request.Path.Value ?? "";

        // ---------------------------------------------------------------------
        // PRE-CHECK: Läs ut nödvändiga headers
        // ---------------------------------------------------------------------
        if (!context.Request.Headers.TryGetValue("X-Client-Id", out var clientIdHeader) ||
            !context.Request.Headers.TryGetValue("X-Timestamp", out var timestampHeader) ||
            !context.Request.Headers.TryGetValue("X-Nonce", out var nonceHeader) ||
            !context.Request.Headers.TryGetValue("X-Signature", out var signatureHeader))
        {
            logger.LogMissingHeaders(remoteIp, path);
            await RejectAsync(context, "Obligatoriska säkerhets-headers saknas.");
            return;
        }

        string clientId = clientIdHeader.ToString();
        string nonce = nonceHeader.ToString();
        string rawTimestamp = timestampHeader.ToString();
        string providedSignature = signatureHeader.ToString();

        // ---------------------------------------------------------------------
        // STEG 1: Är Tidsstämpeln inom godkänt intervall? (±5 min)
        // ---------------------------------------------------------------------
        if (!long.TryParse(rawTimestamp, out var unixTimestamp))
        {
            logger.LogInvalidTimestampFormat(rawTimestamp, clientId, remoteIp);
            await RejectAsync(context, "Ogiltigt format på X-Timestamp (förväntar unix epoch sekunder).");
            return;
        }

        var requestTime = DateTimeOffset.FromUnixTimeSeconds(unixTimestamp);
        var timeDifference = DateTimeOffset.UtcNow - requestTime;

        if (Math.Abs(timeDifference.TotalSeconds) > MaxTimeSkew.TotalSeconds)
        {
            logger.LogTimeSkewExceeded(clientId, timeDifference.TotalSeconds, remoteIp);
            await RejectAsync(context, $"Tidsstämpel utanför tillåtet fönster (±{MaxTimeSkew.TotalMinutes} minuter).");
            return;
        }

        // ---------------------------------------------------------------------
        // STEG 2: Finns (Client-Id + Nonce) i Cachen? (Skydd mot Replay Attack)
        // ---------------------------------------------------------------------
        var cacheKey = $"hmac_nonce:{clientId}:{nonce}";
        
        if (cache.TryGetValue(cacheKey, out _))
        {
            // CRITICAL LOG: Någon försöker spela upp ett tidigare anrop igen!
            logger.LogReplayAttackDetected(clientId, nonce, remoteIp, path);
            await RejectAsync(context, "Återuppspelningsattack upptäckt. Denna Nonce har redan använts.");
            return;
        }

        // ---------------------------------------------------------------------
        // STEG 3: Stämmer HMAC-signaturen?
        // ---------------------------------------------------------------------
        var secretKey = await secretProvider.GetSecretAsync(clientId);
        if (string.IsNullOrEmpty(secretKey))
        {
            logger.LogUnknownClient(clientId, remoteIp);
            await RejectAsync(context, "Ogiltig klient-identifierare.");
            return;
        }

        // Läs in request body och beräkna SHA256-hash
        string bodyHash = await ComputeBodyHashAsync(context.Request);

        // Bygg upp signaturunderlaget (Canonical String)
        var httpMethod = context.Request.Method.ToUpperInvariant();
        var rawDataToSign = $"{httpMethod}\n{path}\n{unixTimestamp}\n{nonce}\n{bodyHash}";

        // Beräkna HMAC-SHA256
        string expectedSignature = ComputeHmacSha256(rawDataToSign, secretKey);

        // Jämför signaturer i KONSTANT TID för att förhindra Timing Attacks
        byte[] providedBytes = Encoding.UTF8.GetBytes(providedSignature);
        byte[] expectedBytes = Encoding.UTF8.GetBytes(expectedSignature);

        if (!CryptographicOperations.FixedTimeEquals(providedBytes, expectedBytes))
        {
            // SECURITY ERROR: Signaturen stämmer inte (innehållet kan ha ändrats i transit)
            logger.LogInvalidSignature(clientId, remoteIp, path);
            await RejectAsync(context, "Ogiltig HMAC-signatur.");
            return;
        }

        // ---------------------------------------------------------------------
        // ALLA STEG GODKÄNDA: Spara Nonce i cachen med TTL = 5 min
        // ---------------------------------------------------------------------
        cache.Set(cacheKey, true, MaxTimeSkew);

        logger.LogValidationSuccess(clientId, nonce);

        // Fortsätt till API-endpointen
        await next(context);
    }

    /// <summary>
    /// Hjälpmetod för att läsa body utan att förstöra strömmen för downstream controllers.
    /// </summary>
    private static async Task<string> ComputeBodyHashAsync(HttpRequest request)
    {
        if (request.ContentLength is null or 0)
        {
            return string.Empty;
        }

        request.EnableBuffering();
        using var sha256 = SHA256.Create();
        var hashBytes = await sha256.ComputeHashAsync(request.Body);
        
        // Återställ strömmens position så att Controller/API-endpoint kan läsa den
        request.Body.Position = 0;
        
        return Convert.ToHexString(hashBytes).ToLowerInvariant();
    }

    private static string ComputeHmacSha256(string data, string secret)
    {
        var keyBytes = Encoding.UTF8.GetBytes(secret);
        var dataBytes = Encoding.UTF8.GetBytes(data);

        using var hmac = new HMACSHA256(keyBytes);
        var hash = hmac.ComputeHash(dataBytes);
        return Convert.ToHexString(hash).ToLowerInvariant();
    }

    /// <summary>
    /// Skickar ett strukturerat 401 Unauthorized ProblemDetails-svar.
    /// </summary>
    private static async Task RejectAsync(HttpContext context, string detail)
    {
        context.Response.StatusCode = StatusCodes.Status401Unauthorized;
        context.Response.ContentType = "application/problem+json";

        var problemDetails = new ProblemDetails
        {
            Status = StatusCodes.Status401Unauthorized,
            Title = "HMAC Autentisering Misslyckades",
            Detail = detail,
            Instance = context.Request.Path
        };

        await context.Response.WriteAsJsonAsync(problemDetails);
    }
}

using MyApi.Security;

var builder = WebApplication.CreateBuilder(args);

// 1. Registrera beroenden
builder.Services.AddControllers();
builder.Services.AddMemoryCache(); // Minnescache för Nonce-lagring
builder.Services.AddSingleton<IClientSecretProvider, InMemoryClientSecretProvider>();

var app = builder.Build();

app.UseHttpsRedirection();

// 2. Koppla Middleware enbart till API-rutter (t.ex. alla anrop under /api)
app.UseWhen(context => context.Request.Path.StartsWithSegments("/api"), appBuilder =>
{
    appBuilder.UseMiddleware<HmacValidationMiddleware>();
});

app.MapControllers();

app.Run();