Elvia.Elvid.TokenClient 2.4.0

Elvia.Elvid.TokenClient

OAuth2 Client Credentials bibliotek for Elvid med automatisk token-håndtering og caching.

Erstatter IdentityModel avhengigheter og duplikat ElvidAccessTokenService kode.

Kom i gang

1. Installer

dotnet add package Elvia.Elvid.TokenClient

2. Konfigurer

// Forutsetter eksisterende Vault-konfigurasjon (AddHashiVaultSecrets)
builder.Services.AddElvidTokenProvider(options =>
{
    options.TokenEndpoint = builder.Configuration.EnsureHasValue("system:kv:elvid:tokenendpoint");
    options.ClientId = builder.Configuration.EnsureHasValue("system:kv:elvid:clientid");
    options.ClientSecret = builder.Configuration.EnsureHasValue("system:kv:elvid:clientsecret");
});

3. Bruk

HttpClient (anbefalt):

// Default provider
builder.Services.AddHttpClient("ExternalApi", client =>
{
    client.BaseAddress = new Uri("https://api.elvia.no/");
})
.AddElvidAuthHandler(); // Automatisk Bearer token fra default provider

// Named provider (for multiple clients)
builder.Services.AddHttpClient("KumaApi", client =>
{
    client.BaseAddress = new Uri("https://kuma.elvia.io/");
})
.AddElvidAuthHandler("kuma"); // Bruker navngitt "kuma" provider

// I service:
var client = _httpClientFactory.CreateClient("ExternalApi");
var response = await client.GetAsync("endpoint"); // Token legges til automatisk

Direkte (Client Credentials):

public class MyService
{
    private readonly IElvidTokenProvider _tokenProvider;
    
    public async Task<string> GetTokenAsync()
    {
        return await _tokenProvider.GetAccessTokenAsync([]);
    }
}

Password Grant (for testing/smoketests):

public class MySmokeTestService
{
    private readonly IElvidTokenProvider _tokenProvider;

    public async Task<string> GetUserTokenAsync()
    {
        return await _tokenProvider.GetAccessTokenAsync("testuser", "testpass", []);
    }
}

Maskinporten Token (via ElvID):

public class MyMaskinportenService
{
    private readonly IElvidTokenProvider _tokenProvider;

    public async Task<string> GetKrrTokenAsync()
    {
        // Henter ElvID-token og veksler det mot Maskinporten-token automatisk
        return await _tokenProvider.GetMaskinportenTokenAsync(
            "maskinporten.krr.global-kontaktinformasjon.read");
    }
}

Standalone bruk (uten Dependency Injection):

// Perfect for smoketests og enkle skript
var tokenProvider = ElvidTokenClientFactory.Create(
    "https://elvid.test-elvia.io/connect/token",
    "your-client-id",
    "your-client-secret");

// Client credentials
var token = await tokenProvider.GetAccessTokenAsync([]);

// Password grant
var userToken = await tokenProvider.GetAccessTokenAsync("testuser", "testpass", []);

Multiple API clients (anbefalt for større systemer):

// Registrer flere navngitte clients
builder.Services.AddElvidTokenProvider("convey", options =>
{
    options.TokenEndpoint = builder.Configuration.EnsureHasValue("elvid:kv:elvid:elvid-convey:tokenendpoint");
    options.ClientId = builder.Configuration.EnsureHasValue("elvid:kv:elvid:elvid-convey:clientid");
    options.ClientSecret = builder.Configuration.EnsureHasValue("elvid:kv:elvid:elvid-convey:clientsecret");
});

builder.Services.AddElvidTokenProvider("kuma", options =>
{
    options.TokenEndpoint = builder.Configuration.EnsureHasValue("elvid:kv:elvid:elvid-kuma:tokenendpoint");
    options.ClientId = builder.Configuration.EnsureHasValue("elvid:kv:elvid:elvid-kuma:clientid");
    options.ClientSecret = builder.Configuration.EnsureHasValue("elvid:kv:elvid:elvid-kuma:clientsecret");
});

// I service - bruk factory til å få riktig client
public class MyService
{
    private readonly IElvidTokenProviderFactory _tokenProviderFactory;

    public async Task CallConveyAsync()
    {
        var conveyProvider = _tokenProviderFactory.GetProvider("convey");
        var token = await conveyProvider.GetAccessTokenAsync([]);
        // Use token for Convey API calls
    }

    public async Task CallKumaAsync()
    {
        var kumaProvider = _tokenProviderFactory.GetProvider("kuma");
        var token = await kumaProvider.GetAccessTokenAsync([]);
        // Use token for Kuma API calls
    }
}

Maskinporten Token Support

TokenClient støtter henting av Maskinporten-tokens via ElvID. Dette forenkler integrasjon mot eksterne tjenester som krever Maskinporten-autentisering.

Bruk

public class ExternalApiService
{
    private readonly IElvidTokenProvider _tokenProvider;

    public async Task CallExternalApiAsync()
    {
        // Henter Maskinporten-token i ett kall
        // Scopet må starte med "maskinporten." og være konfigurert i ElvID
        var maskinportenToken = await _tokenProvider.GetMaskinportenTokenAsync(
            "maskinporten.your-scope-here");

        // Bruk tokenet mot ekstern API
        using var client = new HttpClient();
        client.SetBearerToken(maskinportenToken);

        var response = await client.GetAsync("https://external-api.no/...");
    }
}

Konfigurasjon

builder.Services.AddElvidTokenProvider(options =>
{
    options.TokenEndpoint = builder.Configuration.EnsureHasValue("system:kv:elvid:tokenendpoint");
    options.ClientId = builder.Configuration.EnsureHasValue("system:kv:elvid:clientid");
    options.ClientSecret = builder.Configuration.EnsureHasValue("system:kv:elvid:clientsecret");

    // Valgfritt: Override Maskinporten endpoint. Uten denne utledes endepunktet fra samme
    // ElvID-host som tokenet hentes fra, så både Authority og TokenEndpoint holder.
    // options.MaskinportenTokenEndpoint = "https://elvid.elvia.io/api/maskinporten/token";

    // Valgfritt: Justere cache refresh skew (default: 30 sekunder)
    // options.MaskinportenRefreshSkewSeconds = 30;
});

Hvordan det fungerer

1. Klienten kaller GetMaskinportenTokenAsync("maskinporten.xxx")
2. TokenClient henter først et ElvID-token med det angitte scopet
3. TokenClient kaller ElvID sitt /api/maskinporten/token endepunkt med ElvID-tokenet som Bearer, og sender ?scope= slik at ElvID vet hvilken nedstrøms-API tokenet skal gjelde for
4. ElvID veksler tokenet hos Maskinporten med Elvias virksomhetssertifikat og returnerer resultatet

Merk: Maskinporten-tokens har kort levetid (119 sekunder). TokenClient cacher tokenet per scope og refresher automatisk før det utløper.

Feilhåndtering: ElvidTokenException.Reason forteller hva som gikk galt, og hva du kan gjøre med det:

Bare HttpError retryes. De andre er deterministiske for forespørselen slik den ble sendt, så en ny identisk runde kan ikke gi et annet svar — en 504 har dessuten allerede kostet ElvIDs fulle timeout mot Maskinporten.

JWT Bearer Authentication

For applikasjoner som skal validere ElvID tokens (ikke bare hente dem), tilbyr TokenClient en standardisert JWT authentication setup:

Enkel oppsett:

using Elvia.Elvid.TokenClient.DependencyInjection;

// I Program.cs
var authority = builder.Configuration.EnsureHasValue("elvid:kv:shared:elvidauthority");
builder.Services.AddElvidJwtAuthentication(authority);

// Det er alt! Standardoppsett for ElvID tokens er konfigurert:
// ✅ MapInboundClaims = false (bevarer originale claim types)
// ✅ ValidateAudience = false (ElvID tokens krever ikke audience validering)
// ✅ ValidateIssuer = false (stoler på authority vi konfigurerte)

Før (manuelt oppsett):

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.Authority = authority;
        options.MapInboundClaims = false;
        options.TokenValidationParameters.ValidateAudience = false;
        options.TokenValidationParameters.ValidateIssuer = false;
    });

Etter (TokenClient helper):

builder.Services.AddElvidJwtAuthentication(authority);

Multiple authentication schemes:

// Legg til flere schemes ved behov
builder.Services
    .AddElvidJwtAuthentication("https://elvid.elvia.io") // Default scheme
    .AddElvidJwtBearer("https://other-authority.io", "OtherScheme");

Bruk i controllers:

[Authorize] // Krever gyldig ElvID token
public class MyController : ControllerBase
{
    [HttpGet]
    public IActionResult Get()
    {
        var userId = User.FindFirst("sub")?.Value;
        var email = User.FindFirst("email")?.Value;
        return Ok(new { userId, email });
    }
}

Microsoft Graph API Integration

TokenClient inkluderer innebygd støtte for Microsoft Graph API med automatisk token-håndtering og caching. Perfekt for AD-gruppeoppslag, brukeroppslag, og authorization handlers.

Erstatter: ElvID sin GraphApiService og manuelle Graph API kode i andre systemer.

Konfigurer

using Elvia.Elvid.TokenClient.DependencyInjection;

// I Program.cs
builder.Services.AddElvidGraphClient(options =>
{
    options.TenantId = builder.Configuration.EnsureHasValue("elviaad:tenantid");
    options.ClientId = builder.Configuration.EnsureHasValue("elviaad:clientid");
    options.ClientSecret = builder.Configuration.EnsureHasValue("elviaad:clientsecret");
});

Brukeroppslag

public class UserService
{
    private readonly IElvidGraphClient _graphClient;

    public async Task<GraphUser?> GetUserInfoAsync(string userPrincipalName)
    {
        var user = await _graphClient.GetUserAsync(userPrincipalName);

        if (user != null)
        {
            // ElvID Graph API returnerer kun essensielle felt
            Console.WriteLine($"ID: {user.Id}");
            Console.WriteLine($"Name: {user.DisplayName}");
            Console.WriteLine($"Email: {user.Mail}");
            Console.WriteLine($"UPN: {user.UserPrincipalName}");

            // MERK: Sensitive felt er filtrert bort (telefon, jobbtittel, kontor)
        }

        return user;
    }
}

AD Gruppeoppslag

public class GroupService
{
    private readonly IElvidGraphClient _graphClient;

    // Hent alle gruppe-IDer (rask, cached i 5 min)
    public async Task<string[]> GetUserGroupsAsync(string userPrincipalName)
    {
        return await _graphClient.GetUserGroupIdsAsync(userPrincipalName);
    }

    // Hent alle grupper med detaljer (navn, beskrivelse, etc.)
    public async Task<GraphGroup[]> GetUserGroupDetailsAsync(string userPrincipalName)
    {
        return await _graphClient.GetUserGroupsAsync(userPrincipalName);
    }

    // Sjekk om bruker er medlem av spesifikk gruppe
    public async Task<bool> IsAdminAsync(string userPrincipalName)
    {
        return await _graphClient.IsUserMemberOfGroupAsync(
            userPrincipalName,
            "admin-group-id");
    }

    // Sjekk om bruker er medlem av noen av gruppene
    public async Task<bool> HasAccessAsync(string userPrincipalName)
    {
        var allowedGroups = new[] { "group-1-id", "group-2-id", "group-3-id" };
        return await _graphClient.IsUserMemberOfAnyGroupAsync(
            userPrincipalName,
            allowedGroups);
    }
}

Authorization Handler (ASP.NET Core)

public class AdGroupRequirement : IAuthorizationRequirement
{
    public string[] AllowedGroupIds { get; }

    public AdGroupRequirement(params string[] allowedGroupIds)
    {
        AllowedGroupIds = allowedGroupIds;
    }
}

public class AdGroupHandler : AuthorizationHandler<AdGroupRequirement>
{
    private readonly IElvidGraphClient _graphClient;

    public AdGroupHandler(IElvidGraphClient graphClient)
    {
        _graphClient = graphClient;
    }

    protected override async Task HandleRequirementAsync(
        AuthorizationHandlerContext context,
        AdGroupRequirement requirement)
    {
        var userPrincipalName = context.User.FindFirst("upn")?.Value
                             ?? context.User.FindFirst("preferred_username")?.Value;

        if (userPrincipalName == null) return;

        // IsUserMemberOfAnyGroupAsync bruker cached data (5 min)
        var isMember = await _graphClient.IsUserMemberOfAnyGroupAsync(
            userPrincipalName,
            requirement.AllowedGroupIds);

        if (isMember)
        {
            context.Succeed(requirement);
        }
    }
}

// I Program.cs
builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("AdminOnly", policy =>
        policy.Requirements.Add(new AdGroupRequirement("admin-group-id")));
});

builder.Services.AddSingleton<IAuthorizationHandler, AdGroupHandler>();

Gruppedetaljer og medlemmer

public class GroupManagementService
{
    private readonly IElvidGraphClient _graphClient;

    // Hent info om en gruppe
    public async Task<GraphGroup?> GetGroupInfoAsync(string groupId)
    {
        return await _graphClient.GetGroupAsync(groupId);
    }

    // Hent alle medlemmer i en gruppe (kun IDs - rask)
    public async Task<string[]> GetGroupMemberIdsAsync(string groupId)
    {
        return await _graphClient.GetGroupMemberIdsAsync(groupId);
    }

    // Hent alle medlemmer med grunnleggende brukerinfo (for visning i UI)
    public async Task<GraphUser[]> GetGroupMembersAsync(string groupId)
    {
        var members = await _graphClient.GetGroupMembersAsync(groupId);

        // Hver bruker har kun essensielle felt (personvern):
        // - Id, UserPrincipalName, DisplayName, Mail
        //
        // MERK: Sensitive felt er filtrert bort av ElvID Graph API:
        // - Telefonnummer (MobilePhone, BusinessPhones)
        // - Jobbtittel (JobTitle)
        // - Kontorplassering (OfficeLocation)
        // - Navn-komponenter (GivenName, Surname)

        return members;
    }

    // Hent alle eiere av en gruppe (administratorer)
    public async Task<GraphUser[]> GetGroupOwnersAsync(string groupId)
    {
        // Returnerer samme filtrerte brukerinfo som GetGroupMembersAsync()
        return await _graphClient.GetGroupOwnersAsync(groupId);
    }

    // Hent grunnleggende brukerinfo
    public async Task<GraphUser?> GetUserAsync(string userIdentifier)
    {
        // Kan bruke UPN (user@elvia.no) eller bruker-ID
        // Returnerer samme filtrerte brukerinfo som gruppemedlemmene
        return await _graphClient.GetUserAsync(userIdentifier);
    }
}

Use Case: Meldingsportalen

Viser hvordan Meldingsportalen (eller lignende systemer) kan bruke Graph API:

public class MessagePortalService
{
    private readonly IElvidGraphClient _graphClient;

    // Vise hvem som har tilgang til en melding (basert på gruppe)
    public async Task<List<UserInfo>> GetMessageRecipientsAsync(string groupId)
    {
        // Hent alle medlemmer i gruppen med full info
        var members = await _graphClient.GetGroupMembersAsync(groupId);

        return members.Select(m => new UserInfo
        {
            EntraId = m.Id,
            UserName = m.DisplayName ?? "Unknown",
            Email = m.Mail ?? m.UserPrincipalName
        }).ToList();
    }

    // Identifisere administratorer/ansvarlige
    public async Task<List<UserInfo>> GetGroupAdministratorsAsync(string groupId)
    {
        var owners = await _graphClient.GetGroupOwnersAsync(groupId);

        return owners.Select(o => new UserInfo
        {
            EntraId = o.Id,
            UserName = o.DisplayName ?? "Unknown",
            Email = o.Mail ?? o.UserPrincipalName
        }).ToList();
    }

    // Display navn i UI/logger (optimalisert)
    public async Task<string> GetDisplayNameForLogAsync(string userId)
    {
        // Kun display navn - raskere enn full user lookup
        var displayName = await _graphClient.GetUserDisplayNameAsync(userId);
        return displayName ?? "Unknown User";
    }
}

Fordeler med Graph Integration

• ✅ Automatisk token-håndtering - Ingen manuell håndtering av Graph API tokens
• ✅ Innebygd caching - Gruppeoppslag caches i 5 minutter (konfigurerbart)
• ✅ Thread-safe - Sikker for concurrent requests
• ✅ Retry-logikk - Automatisk retry ved midlertidige feil
• ✅ Personvern innebygd - ElvID Graph API filtrerer sensitive felt automatisk
• ✅ Erstatter GraphApiService - Drop-in replacement for ElvID sin GraphApiService
• ✅ Ingen IdentityModel - Ingen avhengighet til deprecated IdentityModel pakker
• ✅ Type-safe - Sterkt typede modeller for alle operasjoner

Migration fra IdentityModel

Problem: KubernetesClient vulnerability krever oppgradering av Elvia.Configuration, som fjerner IdentityModel avhengigheter.

Løsning: Erstatt IdentityModel med TokenClient.

SetBearerToken Extension Method

TokenClient inkluderer SetBearerToken extension method for enkel migrering:

using Elvia.Elvid.TokenClient.Http;

// Fungerer akkurat som IdentityModel sin SetBearerToken
var token = await _tokenProvider.GetAccessTokenAsync([]);
httpClient.SetBearerToken(token);

Før (IdentityModel - fungerer ikke lenger):

// Krever IdentityModel pakke som ikke lenger er inkludert
var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
    Address = "https://elvid.test-elvia.io/connect/token",
    ClientId = "client-id",
    ClientSecret = "secret"
});
var token = tokenResponse.AccessToken;

Etter (TokenClient - fungerer uten eksterne avhengigheter):

Med Dependency Injection:

// I Program.cs - kun én gang
builder.Services.AddElvidTokenProvider(options =>
{
    options.TokenEndpoint = builder.Configuration.EnsureHasValue("system:kv:elvid:tokenendpoint");
    options.ClientId = builder.Configuration.EnsureHasValue("system:kv:elvid:clientid");
    options.ClientSecret = builder.Configuration.EnsureHasValue("system:kv:elvid:clientsecret");
});

// Client credentials - caches automatisk
var token = await _tokenProvider.GetAccessTokenAsync([]);

// Password grant (for smoketests)
var userToken = await _tokenProvider.GetAccessTokenAsync("testuser", "testpass", []);

Uten Dependency Injection (smoketests):

// Direkte opprettelse - perfect for smoketests
var tokenProvider = ElvidTokenClientFactory.Create(
    "https://elvid.test-elvia.io/connect/token",
    "client-id",
    "client-secret");

var token = await tokenProvider.GetAccessTokenAsync("testuser", "testpass", []);

Fordeler

• ✅ Løser IdentityModel-problem - Ingen avhengighet til IdentityModel eller Duende pakker
• ✅ Client Credentials + Password Grant - Støtter både machine-to-machine og user authentication
• ✅ Maskinporten-støtte - Enkel henting av Maskinporten-tokens via ElvID
• ✅ JWT Bearer Authentication - Standardisert oppsett for validering av ElvID tokens
• ✅ Microsoft Graph API - Innebygd støtte for AD-gruppeoppslag og brukerinfo
• ✅ Automatisk caching - Thread-safe med per-scope, per-user, Maskinporten og Graph API caching
• ✅ Multiple named clients - Factory pattern for separate API konfigurasjoner (Convey, Kuma etc.)
• ✅ HttpClient-integrasjon - Automatisk Bearer token påføring (også uten scopes)
• ✅ Retry-logikk - Én automatisk retry ved transportfeil/5xx; aldri ved avviste forespørsler (4xx) eller når Maskinporten er nede (502/504)
• ✅ Ingen scopes påkrevd - Client credentials flow uten scopes
• ✅ Fjerner duplikat kode - Erstatter ElvidAccessTokenService, GraphApiService og standard authentication setup
• ✅ Perfect for smoketests - Password grant støtte og standalone factory
• ✅ Standalone support - ElvidTokenClientFactory.Create() for bruk uten DI

Publisering

Tag en versjon for å publisere til NuGet:

git tag tokenclient-v1.0.0
git push origin tokenclient-v1.0.0