AuthSub dans les bibliothèques clientes du protocole Google Data

Avertissement : Cette page concerne les anciennes API Google, les API Google Data. Elle n'est pertinente que pour les API listées dans le répertoire des API Google Data, dont beaucoup ont été remplacées par des API plus récentes. Pour en savoir plus sur une nouvelle API spécifique, consultez sa documentation. Pour en savoir plus sur l'autorisation des requêtes avec une API plus récente, consultez Authentification et autorisation des comptes Google.

Ce document explique comment utiliser les bibliothèques clientes des API Google Data pour se connecter à l'authentification AuthSub pour les applications Web de Google.

L'interface AuthSub permet à une application Web d'accéder à un service Google au nom d'un utilisateur. Pour maintenir un niveau de sécurité élevé, l'interface AuthSub permet à l'application d'obtenir un jeton d'authentification sans jamais gérer les informations de connexion au compte de l'utilisateur.

Les bibliothèques clientes des API Google Data fournissent des méthodes pour vous aider à utiliser AuthSub dans votre application Web. Plus précisément, il existe des méthodes pour construire l'URL de la requête, obtenir un jeton d'authentification à usage unique, échanger le jeton à usage unique contre un jeton de session et signer la requête.

Remarque : La bibliothèque cliente JavaScript possède sa propre version d'AuthSub, appelée AuthSubJS. Pour savoir comment utiliser AuthSubJS dans vos applications JavaScript, consultez Utiliser l'authentification "AuthSub" avec la bibliothèque cliente JavaScript.

Audience

Ce document est destiné aux programmeurs qui souhaitent que leurs applications Web accèdent aux services Google pour le compte des utilisateurs, à l'aide des bibliothèques clientes des API Google Data.

Dans ce document, nous partons du principe que vous connaissez l'interface AuthSub et le processus général d'intégration d'AuthSub à votre application Web. Pour obtenir une description complète du protocole AuthSub, consultez Authentification AuthSub pour les applications Web.

Utiliser AuthSub et les API Google Data sans les bibliothèques clientes

Si vous souhaitez que votre client d'application Web interagisse avec un service de données Google à l'aide d'AuthSub comme système d'authentification, vous trouverez toutes les informations nécessaires dans Authentification AuthSub pour les applications Web. Vous n'êtes pas obligé d'utiliser les bibliothèques clientes des API Google Data.

Voici un aperçu de la façon dont votre application peut authentifier un utilisateur à l'aide d'AuthSub :

Votre application crée l'URL AuthSub appropriée, puis redirige l'utilisateur vers cette URL pour qu'il puisse se connecter. Le système AuthSub renvoie l'utilisateur vers l'URL de votre site que vous avez spécifiée et renvoie un jeton à usage unique. Votre application peut éventuellement échanger ce jeton contre un jeton de session. Votre application envoie ensuite le jeton dans l'en-tête d'autorisation avec chaque requête qu'elle envoie au service.

Les bibliothèques clientes des API Google Data simplifient ce processus d'autorisation en gérant divers détails à votre place. Ce document vous explique comment procéder.

Utiliser AuthSub et les API Google Data : exemples de bibliothèques clientes

Cette section présente un exemple d'utilisation des méthodes de la bibliothèque cliente des API Google Data pour suivre les étapes décrites dans la section Utiliser AuthSub de la documentation AuthSub.

Dans cet exemple, nous intégrons l'interface AuthSub à une application Web qui interagit avec Google Agenda (bien que vous n'ayez pas besoin de connaître Google Agenda pour suivre l'exemple). L'exemple suppose que l'application Web est hébergée sur example.com.

Choisissez le type de jeton à utiliser (session=0 ou session=1).

Vous pouvez choisir d'utiliser des jetons à usage unique (session=0) ou des jetons de session (session=1). Ce document utilisera des jetons de session, car ils sont plus utiles dans les applications qui effectueront plusieurs requêtes d'API. Comme indiqué dans la documentation AuthSub, si vous décidez d'utiliser des jetons de session dans votre application Web, vous devrez gérer vous-même le stockage des jetons. Ce document ne traite pas de la gestion des jetons. Notez également que les jetons demandés avec session=0 ne peuvent pas être échangés (mis à niveau) ultérieurement contre un jeton de session de longue durée.

Décidez si vous souhaitez enregistrer votre application Web (secure=0 ou secure=1).

AuthSub peut être utilisé dans trois modes différents : non enregistré, enregistré et enregistré avec sécurité renforcée. Le reste de ce document fera référence à la dernière option sous le nom d'AuthSub sécurisé. Bien que le mode non enregistré/enregistré soit plus simple à configurer que l'authentification AuthSub sécurisée, Google vous encourage à utiliser des jetons sécurisés pour une sécurité renforcée.

Comment s'inscrire

Si vous choisissez Enregistrement pour les applications Web, votre application bénéficiera des avantages suivants :

1. Un niveau de sécurité plus élevé.
2. Être approuvé par Google (aucun avertissement n'est affiché à l'utilisateur sur la page d'autorisation Google)

Registered + Secure AuthSub

Si vous optez pour l'authentification AuthSub sécurisée, vous devrez créer une paire clé privée/certificat public RSA autosignée en plus d'enregistrer votre application Web. Consultez Générer des clés et des certificats à utiliser avec le mode enregistré (ci-dessous) pour obtenir des exemples de création de certificats X.509.

Déterminer le champ d'application de votre accès aux données

Chaque service Google définit une valeur scope qui détermine (et peut-être limite) l'accès d'un jeton aux données de l'utilisateur. Pour obtenir la liste des valeurs scope disponibles, consultez les questions fréquentes.

Comme nous avons décidé d'interagir avec l'API Google Agenda, scope doit être http://www.google.com/calendar/feeds/.

Remarque : Définissez toujours la valeur du champ "Étendue" sur l'URL la plus large possible, sauf si vous avez besoin d'une restriction plus précise. Par exemple, un champ d'application plus étroit tel que scope=http://www.google.com/calendar/feeds/default/allcalendars/full limitera l'accès du jeton au flux allcalendars/full. L'utilisation de scope=http://www.google.com/calendar/feeds/ permet d'accéder à tous les flux d'Agenda : http://www.google.com/calendar/feeds/*.

Jetons à portée multiple

Pour créer des jetons qui accèdent à plusieurs API de données Google, séparez chaque champ d'application par un espace encodé en URL. L'exemple ci-dessous crée un jeton qui aura accès aux données Google Contacts et Google Agenda d'un utilisateur.

scope=http://www.google.com/calendar/feeds/%20http://www.google.com/m8/feeds/

Demander un jeton d'authentification à usage unique

Pour acquérir un jeton AuthSub pour un utilisateur et un service donnés, votre application doit rediriger l'utilisateur vers l'URL AuthSubRequest, qui l'invite à se connecter à son compte Google. (Pour en savoir plus sur l'URL AuthSubRequest, consultez la page complète Authentification AuthSub pour les applications Web.)

Pour créer l'URL AuthSubRequest dans votre application, utilisez les éléments suivants pour chaque bibliothèque cliente :

Java

import com.google.gdata.client.*;

String nextUrl = "http://www.example.com/RetrieveToken.jsp";
String scope = "http://www.google.com/calendar/feeds/";
boolean secure = false;  // set secure=true to request secure AuthSub tokens
boolean session = true;
String authSubUrl = AuthSubUtil.getRequestUrl(nextUrl, scope, secure, session);

Si vous souhaitez authentifier les utilisateurs de votre domaine G Suite :

import com.google.gdata.client.*;

String hostedDomain = "example.com";
String nextUrl = "http://www.example.com/RetrieveToken.jsp";
String scope = "http://www.google.com/calendar/feeds/";
boolean secure = false;  // set secure=true to request AuthSub tokens
boolean session = true;
String authSubUrl = AuthSubUtil.getRequestUrl(hostedDomain, nextUrl, scope, secure, session);

.NET

using Google.GData.Client;

String nextUrl = "http://www.example.com/RetrieveToken.aspx";
String scope = "http://www.google.com/calendar/feeds/";
bool secure = false; // set secure=true to request secure AuthSub tokens
bool session = true;
String authSubUrl = AuthSubUtil.getRequestUrl(nextUrl, scope, secure, session);

Si vous souhaitez authentifier les utilisateurs de votre domaine G Suite :

using Google.GData.Client;

String hostedDomain = "example.com";
String nextUrl = "http://www.example.com/RetrieveToken.aspx";
String scope = "http://www.google.com/calendar/feeds/";
bool secure = false; // set secure=true to request secure AuthSub tokens
bool session = true;
String authSubUrl = AuthSubUtil.getRequestUrl(hostedDomain, nextUrl, scope, secure, session);

PHP

require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata_AuthSub');

$nextUrl = 'http://www.example.com/RetrieveToken.php';
$scope = 'http://www.google.com/calendar/feeds/';
$secure = 0;  // set $secure=1 to request secure AuthSub tokens
$session = 1;
$authSubUrl = Zend_Gdata_AuthSub::getAuthSubTokenUri($nextUrl, $scope, $secure, $session);

Si vous souhaitez authentifier les utilisateurs de votre domaine G Suite :

require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata_AuthSub');

$hostedDomain = 'example.com';
$nextUrl = 'http://www.example.com/RetrieveToken.php';
$scope = 'http://www.google.com/calendar/feeds/';
$secure = 0;  // set $secure=1 to request secure AuthSub tokens
$session = 1;
$authSubUrl = Zend_Gdata_AuthSub::getAuthSubTokenUri($nextUrl, $scope, $secure, $session) . '&hd=' . $hostedDomain;

Python

import gdata.auth

next = 'http://www.example.com/RetrieveToken.pyc'
scope = 'http://www.google.com/calendar/feeds/'
secure = False  # set secure=True to request secure AuthSub tokens
session = True
auth_sub_url = gdata.auth.GenerateAuthSubRequestUrl(next, scope, secure=secure, session=session)

Si vous souhaitez authentifier les utilisateurs de votre domaine G Suite :

import gdata.auth

hosted_domain = 'example.com'
next = 'http://www.example.com/RetrieveToken.pyc'
scope = 'http://www.google.com/calendar/feeds/'
secure = False  # set secure=True to request secure AuthSub tokens
session = True
auth_sub_url = gdata.auth.GenerateAuthSubRequestUrl(next, scope, secure=secure, session=session, domain=hosted_domain)

Une fois l'URL "next" construite, votre application peut l'utiliser de différentes manières pour envoyer l'utilisateur au gestionnaire AuthSubRequest. L'approche la plus courante consiste à afficher une page indiquant à l'utilisateur qu'il doit suivre un lien pour autoriser votre application à accéder à son compte Google, puis à joindre l'URL de la requête au lien. Par exemple, vous pouvez générer la chaîne suivante dans votre application Web :

String authorizationUrl =
        "<p>MyApp needs access to your Google Calendar account to read your Calendar feed. " +
        "To authorize MyApp to access your account, <a href=\"" + authSubUrl + "\">log in to your account</a>.</p>";

L'utilisateur suit le lien vers la page AuthSub de Google et se connecte. Le système AuthSub redirige ensuite l'utilisateur vers votre application, à l'aide de l'URL "next" que vous avez fournie.

Extraire le jeton à usage unique

Lorsque Google redirige l'utilisateur vers votre application, le jeton est ajouté à l'URL "next" en tant que paramètre de requête. Dans les exemples ci-dessus, une fois que l'utilisateur s'est connecté, Google le redirige vers une URL telle que http://www.example.com/RetrieveToken?token=DQAADKEDE. Votre application doit extraire la valeur du jeton à partir du paramètre de requête de son URL.

Si votre application a défini un cookie d'authentification dans le navigateur de l'utilisateur avant de l'envoyer au système AuthSub, votre application peut lire le cookie d'authentification pour identifier l'utilisateur qui est arrivé à cette URL lorsque Google redirige l'utilisateur vers l'URL "next". Vous pouvez utiliser un tel cookie pour associer un ID utilisateur dans votre application au jeton AuthSub récupéré auprès de Google.

Les bibliothèques clientes fournissent des méthodes pratiques pour extraire le jeton à usage unique :

Java

String singleUseToken = AuthSubUtil.getTokenFromReply(httpServletRequest.getQueryString());

.NET

String singleUseToken = Request.QueryString["token"];
// or
String singleUseToken = AuthSubUtil.getTokenFromReply(new Uri(Request.QueryString));

PHP

$singleUseToken = $_GET['token'];

Python

current_url = 'http://' + req.hostname + req.unparsed_uri
# Unlike the other calls, extract_auth_sub_token_from_url() will create an AuthSubToken or SecureAuthSubToken object.
# Use str(single_use_token) to return the token's string value.
single_use_token = gdata.auth.extract_auth_sub_token_from_url(current_url)

Si vous utilisez AuthSub sécurisé, veillez à définir votre clé privée RSA pour qu'un SecureAuthSubToken soit créé :

f = open('/path/to/yourRSAPrivateKey.pem')
rsa_key = f.read()
f.close()
current_url = 'http://' + req.hostname + req.unparsed_uri
# Unlike the other calls, extract_auth_sub_token_from_url() will create an AuthSubToken or SecureAuthSubToken object.
# Use str(single_use_token) to return the token's string value.
single_use_token = gdata.auth.extract_auth_sub_token_from_url(current_url, rsa_key=rsa_key)

Demander un jeton de session

Le jeton que vous récupérez à partir de l'URL est toujours un jeton à usage unique. L'étape suivante consiste à mettre à niveau ce jeton pour obtenir un jeton de session de longue durée à l'aide de l'URL AuthSubSessionToken, comme décrit dans la documentation complète Authentification AuthSub pour les applications Web. Si vous utilisez AuthSub sécurisé, vous devrez définir votre clé privée RSA avant d'effectuer l'échange. Voici quelques exemples d'utilisation de chacune des bibliothèques clientes :

Java

import com.google.gdata.client.*;
import com.google.gdata.client.calendar.*;

String sessionToken = AuthSubUtil.exchangeForSessionToken(singleUseToken, null);

CalendarService calendarService = new CalendarService("google-ExampleApp-v1.0");
calendarService.setAuthSubToken(sessionToken, null);

// ready to interact with Calendar feeds

Pour une authentification AuthSub sécurisée, transmettez votre clé privée RSA à exchangeForSessionToken au lieu de null :

import com.google.gdata.client.*;
import com.google.gdata.client.calendar.*;

java.security.PrivateKey privateKey =
    AuthSubUtil.getPrivateKeyFromKeystore("AuthSubExample.jks", "privKeyPa$$word", "AuthSubExample", "privKeyPa$$word");
String sessionToken = AuthSubUtil.exchangeForSessionToken(singleUseToken, privateKey);

CalendarService calendarService = new CalendarService("google-ExampleApp-v1.0");
calendarService.setAuthSubToken(sessionToken, privateKey);

// ready to interact with Calendar feeds

.NET

using Google.GData.Client;
using Google.GData.Calendar;

String sessionToken = AuthSubUtil.exchangeForSessionToken(singleUseToken, null).ToString();

GAuthSubRequestFactory authFactory = new GAuthSubRequestFactory("cl", "google-ExampleApp-v1.0");
authFactory.Token = (String) sessionToken;

CalendarService calendarService = new CalendarService(authFactory.ApplicationName);
calendarService.RequestFactory = authFactory;

// ready to interact with Calendar feeds

Pour une authentification AuthSub sécurisée, transmettez votre clé privée RSA à exchangeForSessionToken au lieu de null :

using Google.GData.Client;
using Google.GData.Calendar;

protected AsymmetricAlgorithm getRsaKey()
{
  X509Certificate2 cert = new X509Certificate2("C:/MyAspSite/test_cert.pfx", "privKeyPa$$word");
  RSACryptoServiceProvider privateKey = cert.PrivateKey as RSACryptoServiceProvider;
  return privateKey;
}

AsymmetricAlgorithm rsaKey = getRsaKey();
String sessionToken = AuthSubUtil.exchangeForSessionToken(singleUseToken, rsaKey).ToString();

GAuthSubRequestFactory authFactory = new GAuthSubRequestFactory("cl", "google-ExampleApp-v1.0");
authFactory.Token = (String) sessionToken;
authFactory.PrivateKey = rsaKey;

CalendarService calendarService = new CalendarService(authFactory.ApplicationName);
calendarService.RequestFactory = authFactory;

// ready to interact with Calendar feeds

PHP

require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata_AuthSub');
Zend_Loader::loadClass('Zend_Gdata_Calendar');

$sessionToken = Zend_Gdata_AuthSub::getAuthSubSessionToken($singleUseToken);

// Create a Calendar service object and set the session token for subsequent requests
$calendarService = new Zend_Gdata_Calendar(null, 'google-ExampleApp-v1.0');
$calendarService->setAuthSubToken($sessionToken);

// ready to interact with Calendar feeds

Pour sécuriser AuthSub, l'échange vous oblige à configurer d'abord un Zend_Gdata_HttpClient et à définir votre clé privée RSA à l'aide de setAuthSubPrivateKeyFile() :

require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata_AuthSub');
Zend_Loader::loadClass('Zend_Gdata_Calendar');

$client = new Zend_Gdata_HttpClient();
$client->setAuthSubPrivateKeyFile('/path/to/myrsakey.pem', null, true);
$sessionToken = Zend_Gdata_AuthSub::getAuthSubSessionToken($singleUseToken, $client);

$calendarService = new Zend_Gdata_Calendar($client, 'google-ExampleApp-v1.0');
$calendarService->setAuthSubToken($sessionToken);

// ready to interact with Calendar feeds

Python

import gdata.calendar
import gdata.calendar.service

calendar_service = gdata.calendar.service.CalendarService()
calendar_service.UpgradeToSessionToken(single_use_token)  # calls gdata.service.SetAuthSubToken() for you

# ready to interact with Calendar feeds

Remarque : La procédure est la même pour AuthSub sécurisé, à condition que vous ayez utilisé gdata.auth.extract_auth_sub_token_from_url(url, rsa_key=rsa_key) pour extraire le jeton à usage unique.

Remarque : Lorsque vous utilisez AuthSub sécurisé, votre clé privée elle-même n'est pas envoyée sur le réseau. Les bibliothèques clientes envoient la signature unique générée en signant la requête avec votre clé, et non la clé elle-même.

Utiliser le jeton de session

Vous pouvez utiliser le jeton de session pour authentifier les requêtes envoyées au serveur en plaçant le jeton dans l'en-tête "Authorization", comme décrit dans la documentation AuthSub.

Une fois votre jeton de session défini, vous pouvez utiliser les appels de bibliothèque cliente standard des API Google Data pour interagir avec le service, sans avoir à vous soucier du jeton. Pour en savoir plus, consultez la documentation de la bibliothèque cliente et le guide du développeur des API Google Data pour le service et le langage avec lesquels vous interagissez.

Récupérer des informations sur un jeton de session

Si vous souhaitez vérifier que votre client et le serveur s'accordent sur les paramètres du jeton, vous pouvez transmettre le jeton au gestionnaire AuthSubTokenInfo, qui renvoie un ensemble de paires nom/valeur contenant des informations sur le jeton.

Java

Map<String, String> tokenInfo = AuthSubUtil.getTokenInfo(sessionToken, null);

Si vous utilisez AuthSub sécurisé, transmettez votre clé privée RSA :

Map<String, String> tokenInfo = AuthSubUtil.getTokenInfo(sessionToken, privateKey);

.NET

Dictionary<String, String> tokenInfo = AuthSubUtil.GetTokenInfo(sessionToken, null);

Si vous utilisez AuthSub sécurisé, transmettez votre clé privée RSA :

Dictionary<String, String> tokenInfo = AuthSubUtil.GetTokenInfo(sessionToken, privateKey);

PHP

$tokenInfo = Zend_Gdata_AuthSub::getAuthSubTokenInfo($sessionToken);

Si vous utilisez AuthSub sécurisé, transmettez votre Zend_Gdata_HttpClient afin que la requête soit signée avec votre clé privée RSA :

$tokenInfo = Zend_Gdata_AuthSub::getAuthSubTokenInfo($sessionToken, $client);

Python

token_info = calendar_service.AuthSubTokenInfo()

Révoquer un jeton de session

Les jetons de session AuthSub n'expirent pas. Votre client peut stocker le jeton de session aussi longtemps que nécessaire.

Par conséquent, lorsque votre client a fini d'utiliser le jeton de session, il peut le révoquer à l'aide du gestionnaire AuthSubRevokeToken, comme décrit dans la documentation AuthSub.

Par exemple, si vous souhaitez gérer les jetons de manière traditionnelle, comme une session, votre client peut obtenir un jeton au début de la session d'un utilisateur et le révoquer à la fin de la session.

Pour révoquer un jeton, utilisez les éléments suivants dans chaque bibliothèque cliente :

Java

AuthSubUtil.revokeToken(sessionToken, null);

Si vous utilisez AuthSub sécurisé, transmettez votre clé privée RSA :

AuthSubUtil.revokeToken(sessionToken, privateKey);

.NET

AuthSubUtil.revokeToken(sessionToken, null);

Si vous utilisez AuthSub sécurisé, transmettez votre clé privée RSA :

AuthSubUtil.revokeToken(sessionToken, privateKey);

PHP

$wasRevoked = Zend_Gdata_AuthSub::AuthSubRevokeToken($sessionToken);

Si vous utilisez AuthSub sécurisé, transmettez votre Zend_Gdata_HttpClient afin que la requête soit signée avec votre clé privée RSA :

$wasRevoked = Zend_Gdata_AuthSub::AuthSubRevokeToken($sessionToken, $client);

Python

calendar_service.RevokeAuthSubToken()

Ressources et exemples supplémentaires

• Exemples AuthSub sur le blog de conseils sur les API Google Data
• Exemple AuthSub de la bibliothèque cliente Python
• Exemple AuthSub de la bibliothèque cliente Java
• Article : Utiliser AuthSub avec la bibliothèque cliente .NET
• Article : Utiliser l'authentification "AuthSub" avec la bibliothèque cliente JavaScript

Haut de page

Générer une clé privée et un certificat public autosignés à utiliser avec AuthSub sécurisé

La clé privée permet de générer une signature, qui doit être incluse dans chaque requête. Google utilise la clé publique intégrée au certificat pour valider la signature. La clé publique doit être une clé RSA de 1 024 bits encodée dans un certificat X.509 au format PEM. Le certificat doit être envoyé à Google au moment de l'enregistrement.

Les sections suivantes fournissent des exemples de génération de clés et de certificats à l'aide de deux outils spécifiques : l'utilitaire OpenSSL et l'utilitaire keytool de Java.

Ces exemples ne sont pas spécifiques aux API Google Data. Vous pouvez utiliser les mêmes utilitaires pour générer des clés à n'importe quelle fin.

Les exemples supposent que votre entreprise s'appelle My_Company, qu'elle est située à Mountain View, en Californie (États-Unis), et que son nom de domaine est example.com.

Générer des clés à l'aide d'OpenSSL

Pour créer une paire de clés RSA et le certificat correspondant, vous pouvez utiliser la commande suivante :

# Generate the RSA keys and certificate
openssl req -x509 -nodes -days 365 -newkey rsa:1024 -sha1 -subj \
  '/C=US/ST=CA/L=Mountain View/CN=www.example.com' -keyout \
  myrsakey.pem -out /tmp/myrsacert.pem

Avertissement : L'inclusion du paramètre -nodes crée une clé privée sans mot de passe pour la protéger. Toutefois, pour plus de sécurité, vous pouvez envisager d'omettre ce paramètre.

Le paramètre -sha1 spécifie que la clé sera utilisée pour générer des signatures SHA1.

Le paramètre -subj spécifie l'identité de l'application que représente le certificat.

Le paramètre -keyout spécifie le fichier qui contiendra les clés. Ce fichier contient des informations sensibles. Vous devez le protéger et ne le partager avec personne.

Le paramètre -out spécifie le fichier qui contiendra le certificat au format PEM (qui peut être envoyé à Google lors de l'enregistrement).

Générer des clés pour le client .NET

Le framework .NET ne reconnaît pas les clés ni les certificats stockés au format PEM. Par conséquent, une étape supplémentaire est nécessaire une fois le fichier .pem créé :

openssl pkcs12 -export -in test_cert.pem -inkey myrsacert.pem -out myrsacert.pfx -name "Testing Certificate"

Cette étape génère un fichier PFX à partir de votre clé privée et de votre certificat. Ce fichier peut être importé dans la bibliothèque cliente .NET pour signer numériquement les requêtes envoyées aux API Google Data.

Générer des clés pour le client Java

Le client Java accepte les clés privées au format PKCS#8. Après avoir généré une clé/un certificat en suivant les instructions ci-dessus, créez un fichier .pk8 à partir du fichier .pem généré :

openssl pkcs8 -in myrsakey.pem -topk8 -nocrypt -out myrsakey.pk8

Vous pouvez également utiliser le magasin de clés Java et l'utilitaire keytool pour créer une paire de clés RSA et le certificat correspondant. Exécutez la commande suivante :

# Generate the RSA keys and certificate
keytool -genkey -v -alias Example -keystore ./Example.jks\
  -keyalg RSA -sigalg SHA1withRSA\
  -dname "CN=www.example.com, OU=Engineering, O=My_Company, L=Mountain  View, ST=CA, C=US"\
  -storepass changeme -keypass changeme

Avertissement : "changeme" n'est pas un bon mot de passe. Il s'agit simplement d'un exemple.

Le paramètre -dname spécifie l'identité de l'application que représente le certificat. Le paramètre -storepass spécifie le mot de passe permettant de protéger le keystore. Le paramètre -keypass spécifie le mot de passe permettant de protéger la clé privée.

Pour écrire le certificat dans un fichier pouvant être utilisé dans l'outil ManageDomains, exécutez la commande suivante :

# Output the public certificate to a file
keytool -export -rfc -keystore ./Example.jks -storepass changeme \
  -alias Example -file mycert.pem

Haut de page