Comment valider Azure AD jeton de sécurité?

Il y a deux étapes pour vérifier le jeton. Tout d'abord, vérifier la signature de la marque à garantir le jeton a été émis par Azure Active Directory. Deuxièmement, vérifier les déclarations du jeton basé sur la logique métier.

Par exemple, nous avons besoin de vérifier la iss et aud réclamation si vous avez l'élaboration d'un seul locataire de l'app. Et vous avez aussi besoin de vérifier le nbf pour assurer le jeton n'est pas expiré. Plus de réclamations que vous pouvez vous référer ici.

Description ci-dessous est de ici sur le détail de la signature à vérifier. (Remarque: L'exemple ci-dessous utilise Azure AD v2 point de terminaison. Vous devez utiliser le point de terminaison qui correspond au point de terminaison de l'application cliente utilise.)

Le jeton d'accès de l'Azure AD est un JSON Web Jeton(JWT) qui est signé par le Service de Jeton de Sécurité de la clé privée.

Le JWT comprend 3 parties: l'en-tête, des données et de la signature. Techniquement, on peut utiliser la clé publique de valider le jeton d'accès.

Première étape de récupérer et de mettre en cache le chant des jetons (clé publique)

Point de terminaison: https://login.microsoftonline.com/common/v2.0/.well-known/openid-configuration

Ensuite, nous pouvons utiliser la JwtSecurityTokenHandler pour vérifier le jeton à l'aide de l'exemple de code ci-dessous:

 public JwtSecurityToken Validate(string token)
 {
     string stsDiscoveryEndpoint = "https://login.microsoftonline.com/common/v2.0/.well-known/openid-configuration";

     ConfigurationManager<OpenIdConnectConfiguration> configManager = new ConfigurationManager<OpenIdConnectConfiguration>(stsDiscoveryEndpoint);

     OpenIdConnectConfiguration config = configManager.GetConfigurationAsync().Result;

     TokenValidationParameters validationParameters = new TokenValidationParameters
     {
         ValidateAudience = false,
         ValidateIssuer = false,
         IssuerSigningTokens = config.SigningTokens,
         ValidateLifetime = false
     };

     JwtSecurityTokenHandler tokendHandler = new JwtSecurityTokenHandler();

     SecurityToken jwt;

     var result = tokendHandler.ValidateToken(token, validationParameters, out jwt);

     return jwt as JwtSecurityToken;
 }

Et si vous utilisiez le OWIN composants de votre projet, il est plus facile de vérifier le jeton. Nous pouvons utiliser le code ci-dessous pour vérifier le jeton:

app.UseWindowsAzureActiveDirectoryBearerAuthentication(
            new WindowsAzureActiveDirectoryBearerAuthenticationOptions
            {
                Audience = ConfigurationManager.AppSettings["ida:Audience"],
                Tenant = ConfigurationManager.AppSettings["ida:Tenant"]
            });

Ensuite, nous pouvons utiliser le code ci-dessous pour vérifier le "champ d'application" dans le jeton:

public IEnumerable<TodoItem> Get()
{
    //user_impersonation is the default permission exposed by applications in AAD
    if (ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/scope").Value != "user_impersonation")
    {
        throw new HttpResponseException(new HttpResponseMessage {
          StatusCode = HttpStatusCode.Unauthorized,
          ReasonPhrase = "The Scope claim does not contain 'user_impersonation' or scope claim not found"
        });
    }
    ...
}

Et voici un exemple de code qui a protégé les API web avec Azure AD:

Protéger une API Web à l'aide de Porteur de jetons de Azure AD

Mais si vous n'êtes pas à l'aide de OWIN dans vos projets, il va être un peu dur ou au moins de temps..
Cet articleIci est une grande ressource.

Et parce que je n'ai pas grand-chose à ajouter sur le dessus, à l'exception du code.. Ici est quelque chose qui peut être utile pour vous:

 public async Task<ClaimsPrincipal> CreatePrincipleAsync()
{
AzureActiveDirectoryToken azureToken = Token.FromJsonString<AzureActiveDirectoryToken>();
var allParts = azureToken.IdToken.Split(".");
var header = allParts[0];
var payload = allParts[1];
var idToken = payload.ToBytesFromBase64URLString().ToAscii().FromJsonString<AzureActiveDirectoryIdToken>();
allParts = azureToken.AccessToken.Split(".");
header = allParts[0];
payload = allParts[1];
var signature = allParts[2];
var accessToken = payload.ToBytesFromBase64URLString().ToAscii().FromJsonString<AzureActiveDirectoryAccessToken>();
var accessTokenHeader = header.ToBytesFromBase64URLString().ToAscii().FromJsonString<AzureTokenHeader>();
var isValid = await ValidateToken(accessTokenHeader.kid, header, payload, signature);
if (!isValid)
{
throw new SecurityException("Token can not be validated");
}
var principal = await CreatePrincipalAsync(accessToken, idToken);
return principal;
}
private async Task<bool> ValidateToken(string kid, string header, string payload, string signature)
{
string keysAsString = null;
const string microsoftKeysUrl = "https://login.microsoftonline.com/common/discovery/keys";
using (var client = new HttpClient())
{
keysAsString = await client.GetStringAsync(microsoftKeysUrl);
}
var azureKeys = keysAsString.FromJsonString<MicrosoftConfigurationKeys>();
var signatureKeyIdentifier = azureKeys.Keys.FirstOrDefault(key => key.kid.Equals(kid));
if (signatureKeyIdentifier.IsNotNull())
{
var signatureKey = signatureKeyIdentifier.x5c.First();
var certificate = new X509Certificate2(signatureKey.ToBytesFromBase64URLString());
var rsa = certificate.GetRSAPublicKey();
var data = string.Format("{0}.{1}", header, payload).ToBytes();
var isValidSignature = rsa.VerifyData(data, signature.ToBytesFromBase64URLString(), HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
return isValidSignature;
}
return false;
}

Il y a quelques fonctions que j'utilise ici qui ne sont pas disponibles pour vous, ils sont auto-descriptif.