AIDE .NET

C# OAuth2 (Comment ça marche pour les développeurs)

Publié mars 6, 2024

OAuth2 est un protocole puissant qui permet de sécuriser vos applications web en gérant l'authentification et l'autorisation des utilisateurs. Dans le domaine du développement C#, la compréhension d'OAuth2 peut considérablement améliorer la sécurité et la fonctionnalité de vos applications.

Ce guide s'adresse aux débutants et met l'accent sur les concepts clés, les exemples pratiques et les explications faciles à comprendre. Nous apprendrons également un cas d'utilisation d'OAuth2 avec l'applicationIronPDF bibliothèque.

Comprendre OAuth2 et son importance

C# OAuth2(Comment ça marche pour les développeurs) : Figure 1 - Page web OAuth2

OAuth2 est un protocole qui permet à une application cliente de demander l'accès à des ressources hébergées par un serveur d'autorisation, au nom d'un utilisateur. Il s'agit d'une méthode courante pour gérer l'authentification et l'autorisation des utilisateurs dans les applications web modernes.

L'objectif principal d'OAuth2 est de fournir un accès sécurisé et efficace aux ressources sans partager les informations d'identification de l'utilisateur(comme le nom d'utilisateur et le mot de passe) directement avec l'application cliente.

Concepts clés d'OAuth2

Avant de plonger dans la mise en œuvre, clarifions certains termes essentiels d'OAuth2 :

Application client : L'application qui demande l'accès au compte de l'utilisateur.
Serveur d'autorisation : Le serveur qui authentifie l'utilisateur et délivre des jetons d'accès à l'application cliente.
Jeton d'accès : Un jeton qui permet à l'application cliente d'accéder au compte de l'utilisateur pour une durée limitée.
Token de rafraîchissement : Jeton utilisé pour obtenir un nouveau jeton d'accès lorsque le jeton actuel expire sans que les informations d'identification de l'utilisateur ne soient à nouveau requises.
Identification du client et Secret du client : Les informations d'identification qui permettent d'identifier l'application client auprès du serveur d'autorisation.
Redirect URI : URI que le serveur d'autorisation enverra à l'utilisateur après avoir accordé ou refusé l'accès à l'application client.
Flux de code d'autorisation : Méthode sécurisée dans laquelle l'application client reçoit un code d'autorisation en tant qu'étape intermédiaire avant de l'échanger contre un jeton d'accès.

Mise en œuvre d'OAuth2 en C# : Un exemple de base

Créons une application C# simple qui utilise OAuth2 pour l'authentification des utilisateurs. Cet exemple vous guidera dans la configuration d'un client OAuth2, l'obtention d'un jeton d'accès et la soumission d'une requête à une ressource protégée.

Configuration du client OAuth2

Tout d'abord, vous devez enregistrer votre application C# auprès du serveur d'autorisation OAuth2. Ce processus varie en fonction du serveur, mais vous recevrez généralement un identifiant et un secret client, qui sont essentiels pour le flux OAuth2.

Étape 1 : Définir les références de votre application

La première étape consiste à définir les informations d'identification du client, telles que l'identifiant et les secrets du client. Voici un exemple de code :

class Program
{
    private static string clientId = "your-client-id";
    private static string clientSecret = "your-client-secret";
    private static string redirectUri = "your-redirect-uri";
    static void Main(string [] args)
    {
        // OAuth2 implementation will go here
    }
}

class Program
{
    private static string clientId = "your-client-id";
    private static string clientSecret = "your-client-secret";
    private static string redirectUri = "your-redirect-uri";
    static void Main(string [] args)
    {
        // OAuth2 implementation will go here
    }
}

Friend Class Program
	Private Shared clientId As String = "your-client-id"
	Private Shared clientSecret As String = "your-client-secret"
	Private Shared redirectUri As String = "your-redirect-uri"
	Shared Sub Main(ByVal args() As String)
		' OAuth2 implementation will go here
	End Sub
End Class

VB C#

Étape 2 : Demander l'autorisation de l'utilisateur

Pour lancer le flux OAuth2, rediriger l'utilisateur vers le point final d'autorisation du serveur d'autorisation. Voici comment construire l'URL pour la demande d'autorisation :

static void Main(string [] args)
{
    var authorizationEndpoint = "https://authorization-server.com/auth";
    var responseType = "code";
    var scope = "email profile";
    var authorizationUrl = $"{authorizationEndpoint}?response_type={responseType}&client_id={clientId}&redirect_uri={redirectUri}&scope={scope}";
    // Redirect the user to authorizationUrl
}

static void Main(string [] args)
{
    var authorizationEndpoint = "https://authorization-server.com/auth";
    var responseType = "code";
    var scope = "email profile";
    var authorizationUrl = $"{authorizationEndpoint}?response_type={responseType}&client_id={clientId}&redirect_uri={redirectUri}&scope={scope}";
    // Redirect the user to authorizationUrl
}

Shared Sub Main(ByVal args() As String)
	Dim authorizationEndpoint = "https://authorization-server.com/auth"
	Dim responseType = "code"
	Dim scope = "email profile"
	Dim authorizationUrl = $"{authorizationEndpoint}?response_type={responseType}&client_id={clientId}&redirect_uri={redirectUri}&scope={scope}"
	' Redirect the user to authorizationUrl
End Sub

VB C#

Étape 3 : Traitement de la réponse d'autorisation

Une fois que l'utilisateur a accordé ou refusé la permission, le serveur d'autorisation le redirige vers votre application avec un code d'autorisation ou un message d'erreur. Vous devez capturer ce code à partir des paramètres de requête de l'URI de redirection.

Étape 4 : Échange du code d'autorisation

Vous allez maintenant échanger le code d'autorisation contre un jeton d'accès. Cela nécessite une requête POST au point de terminaison du jeton du serveur d'autorisation.

public static async Task<string> ExchangeAuthorizationCodeForAccessToken(string authorizationCode)
{
    var tokenEndpoint = "https://authorization-server.com/token";
    var postData = $"grant_type=authorization_code&code={authorizationCode}&redirect_uri={redirectUri}&client_id={clientId}&client_secret={clientSecret}";
    var data = Encoding.ASCII.GetBytes(postData);
    var request = WebRequest.Create(tokenEndpoint);
    request.Method = "POST";
    request.ContentType = "application/x-www-form-urlencoded";
    request.ContentLength = data.Length;
    using (var stream = request.GetRequestStream())
    {
        stream.Write(data, 0, data.Length);
    }
    var response = (HttpWebResponse)request.GetResponse();
    var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();
    // Extract the access token from the response
    var token = ExtractAccessTokenFromResponse(responseString);
    return token;
}

public static async Task<string> ExchangeAuthorizationCodeForAccessToken(string authorizationCode)
{
    var tokenEndpoint = "https://authorization-server.com/token";
    var postData = $"grant_type=authorization_code&code={authorizationCode}&redirect_uri={redirectUri}&client_id={clientId}&client_secret={clientSecret}";
    var data = Encoding.ASCII.GetBytes(postData);
    var request = WebRequest.Create(tokenEndpoint);
    request.Method = "POST";
    request.ContentType = "application/x-www-form-urlencoded";
    request.ContentLength = data.Length;
    using (var stream = request.GetRequestStream())
    {
        stream.Write(data, 0, data.Length);
    }
    var response = (HttpWebResponse)request.GetResponse();
    var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();
    // Extract the access token from the response
    var token = ExtractAccessTokenFromResponse(responseString);
    return token;
}

Public Shared Async Function ExchangeAuthorizationCodeForAccessToken(ByVal authorizationCode As String) As Task(Of String)
	Dim tokenEndpoint = "https://authorization-server.com/token"
	Dim postData = $"grant_type=authorization_code&code={authorizationCode}&redirect_uri={redirectUri}&client_id={clientId}&client_secret={clientSecret}"
	Dim data = Encoding.ASCII.GetBytes(postData)
	Dim request = WebRequest.Create(tokenEndpoint)
	request.Method = "POST"
	request.ContentType = "application/x-www-form-urlencoded"
	request.ContentLength = data.Length
	Using stream = request.GetRequestStream()
		stream.Write(data, 0, data.Length)
	End Using
	Dim response = CType(request.GetResponse(), HttpWebResponse)
	Dim responseString = (New StreamReader(response.GetResponseStream())).ReadToEnd()
	' Extract the access token from the response
	Dim token = ExtractAccessTokenFromResponse(responseString)
	Return token
End Function

VB C#

Cette fonction envoie une requête POST au point de terminaison du jeton avec les données nécessaires et renvoie le jeton d'accès extrait de la réponse.

Étape 5 : Faire des demandes autorisées

Avec le jeton d'accès, vous pouvez maintenant faire des demandes aux ressources qui requièrent une authentification. Attachez le jeton d'accès à vos demandes dans l'en-tête d'autorisation en tant que jeton Bearer.

public static async Task<string> MakeAuthorizedRequest(string accessToken, string apiUrl)
{
    var request = WebRequest.Create(apiUrl);
    request.Headers.Add("Authorization", $"Bearer {accessToken}");
    var response = (HttpWebResponse)request.GetResponse();
    var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();
    return responseString;
}

public static async Task<string> MakeAuthorizedRequest(string accessToken, string apiUrl)
{
    var request = WebRequest.Create(apiUrl);
    request.Headers.Add("Authorization", $"Bearer {accessToken}");
    var response = (HttpWebResponse)request.GetResponse();
    var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();
    return responseString;
}

Public Shared Async Function MakeAuthorizedRequest(ByVal accessToken As String, ByVal apiUrl As String) As Task(Of String)
	Dim request = WebRequest.Create(apiUrl)
	request.Headers.Add("Authorization", $"Bearer {accessToken}")
	Dim response = CType(request.GetResponse(), HttpWebResponse)
	Dim responseString = (New StreamReader(response.GetResponseStream())).ReadToEnd()
	Return responseString
End Function

VB C#

Introduction à IronPDF

C# OAuth2(Comment ça marche pour les développeurs) : Figure 2 - Page web d'IronPDF

IronPDF est une bibliothèque polyvalente pour les développeurs C# qui permet la génération, la manipulation et le rendu de documents PDF directement dans les applications .NET. Cet outil puissant simplifie le travail avec les fichiers PDF et facilite la création de documents complexes,convertir HTML en PDF sans effort, extraire du texte des PDF, et bien plus encore. Son API simple permet aux développeurs d'intégrer rapidement des fonctionnalités PDF dans leurs applications, sans avoir besoin d'une connaissance approfondie des spécifications PDF.

IronPDF excelle dans les domaines suivants**Conversion de HTML en PDFla traduction doit également respecter la mise en page et les styles. Cette fonction permet de générer des PDF à partir de contenus web, ce qui est utile pour les rapports, les factures et la documentation. Il permet de convertir des fichiers HTML, des URL et des chaînes HTML en PDF.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

VB C#

Exemple de code : Générer un PDF à partir d'un contenu protégé

Imaginez que vous ayez un point de terminaison qui renvoie un contenu HTML accessible uniquement aux utilisateurs authentifiés. Vous pourriez utiliser IronPDF pour convertir ce contenu HTML en document PDF, en tirant parti du jeton d'accès obtenu via OAuth2.

Tout d'abord, définissons une méthode pour récupérer le contenu HTML protégé à l'aide d'un jeton d'accès :

public static async Task<string> FetchProtectedContent(string accessToken, string apiUrl)
{
    var httpClient = new HttpClient();
    httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", accessToken);
    var response = await httpClient.GetAsync(apiUrl);
    response.EnsureSuccessStatusCode();
    return await response.Content.ReadAsStringAsync();
}

public static async Task<string> FetchProtectedContent(string accessToken, string apiUrl)
{
    var httpClient = new HttpClient();
    httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", accessToken);
    var response = await httpClient.GetAsync(apiUrl);
    response.EnsureSuccessStatusCode();
    return await response.Content.ReadAsStringAsync();
}

Public Shared Async Function FetchProtectedContent(ByVal accessToken As String, ByVal apiUrl As String) As Task(Of String)
	Dim httpClient As New HttpClient()
	httpClient.DefaultRequestHeaders.Authorization = New System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", accessToken)
	Dim response = Await httpClient.GetAsync(apiUrl)
	response.EnsureSuccessStatusCode()
	Return Await response.Content.ReadAsStringAsync()
End Function

VB C#

Utilisons maintenant IronPDF pour convertir le contenu HTML récupéré en document PDF :

public static async Task ConvertHtmlToPdf(string accessToken, string apiUrl, string outputPdfPath)
{
    // Fetch protected content using the access token
    string htmlContent = await FetchProtectedContent(accessToken, apiUrl);
    // Use IronPDF to convert the HTML content to a PDF document
    var renderer = new IronPdf.HtmlToPdf();
    var pdf = renderer.RenderHtmlAsPdf(htmlContent);
    // Save the generated PDF to a file
    pdf.SaveAs(outputPdfPath);
}

public static async Task ConvertHtmlToPdf(string accessToken, string apiUrl, string outputPdfPath)
{
    // Fetch protected content using the access token
    string htmlContent = await FetchProtectedContent(accessToken, apiUrl);
    // Use IronPDF to convert the HTML content to a PDF document
    var renderer = new IronPdf.HtmlToPdf();
    var pdf = renderer.RenderHtmlAsPdf(htmlContent);
    // Save the generated PDF to a file
    pdf.SaveAs(outputPdfPath);
}

Public Shared Async Function ConvertHtmlToPdf(ByVal accessToken As String, ByVal apiUrl As String, ByVal outputPdfPath As String) As Task
	' Fetch protected content using the access token
	Dim htmlContent As String = Await FetchProtectedContent(accessToken, apiUrl)
	' Use IronPDF to convert the HTML content to a PDF document
	Dim renderer = New IronPdf.HtmlToPdf()
	Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
	' Save the generated PDF to a file
	pdf.SaveAs(outputPdfPath)
End Function

VB C#

Dans le code ci-dessus, FetchProtectedContent est chargé de récupérer le contenu HTML d'une ressource protégée à l'aide d'un jeton d'accès OAuth2. Une fois le contenu HTML récupéré, il est transmis au moteur de rendu HtmlToPdf d'IronPDF pour générer un document PDF, qui est ensuite enregistré dans le chemin d'accès spécifié.

Conclusion

C# OAuth2(Comment ça marche pour les développeurs) : Figure 3 - Page de licence IronPDF

Ce guide a présenté les bases de l'utilisation d'OAuth2 dans les applications C#, en couvrant les concepts clés, la terminologie et un exemple de mise en œuvre simple. OAuth2 joue un rôle essentiel dans la sécurisation des applications web en gérant efficacement l'authentification et l'autorisation des utilisateurs. Bien que cet exemple présente le flux du code d'autorisation, OAuth2 prend en charge d'autres flux adaptés à différents types d'applications.

En intégrantIronPDF pour la manipulation avancée des PDFles développeurs C# peuvent étendre les capacités de leurs applications à la génération et à la manipulation de fichiers PDF, enrichissant ainsi les fonctions disponibles pour les utilisateurs authentifiés. La facilité d'utilisation d'IronPDF et ses capacités complètes de manipulation des PDF en font un excellent outil pour les développeurs .NET qui souhaitent travailler avec des fichiers PDF dans le cadre de leurs projets. Il offre uneessai gratuit pour découvrir toutes les fonctionnalités et ses licences commencent à partir de $749.

< PRÉCÉDENT
C# WebRTC (Comment ça marche pour les développeurs)

SUIVANT >
Opérateur C# (Comment ça marche pour les développeurs)