1Mise en œuvre du SSO par clés publiques et privées

NOTE TECHNIQUE
Mise en œuvre du SSO par clés
publiques et privées
1
[TN]
1
La mise en œuvre du SSO (Single sign-on) dans une application W4 BPMN+ passe par
la gestion d’une combinaison de clé publique / clé privée pour cette application. La clé
privée est portée par l’application tandis que la clé publique est transmise aux utilisateurs W4 BPMN+ Engine concernés.
NAVIGATION
COMING UP TOPICS
1.1
[TN]
GESTION DU SSO DANS UNE APPLICATION W4 BPMN+, PG 1
EXEMPLE DE CODE, PG 4
Gestion du SSO dans une application W4 BPMN+
Le principe est le suivant :
 Génération d’une clé publique et d’une clé privée
 Attribution de la clé publique aux utilisateurs concernés
 Récupération de l’utilisateur connecté
 Positionnement des clés privée et publique dans le fichier ini de l’application
NAVIGATION
HEADINGS IN THIS TOPIC
GÉNÉRATION DE LA CLÉ PUBLIQUE ET DE LA CLÉ PRIVÉE, PG 2
ATTRIBUTION DE LA CLÉ PUBLIQUE AUX UTILISATEURS CONCERNÉS, PG 2
RÉCUPÉRATION DE L’UTILISATEUR CONNECTÉ, PG 2
POSITIONNEMENT DES CLÉS PUBLIQUE ET PRIVÉE DANS LE FICHIER INI, PG 3
2
2
body
1.1.1
Génération de la clé publique et de la clé privée
Pour générer la clé publique et la clé privée, utilisez le programme keyPairGenerator,
situé dans le dossier tools/keyPairGenerator du répertoire d’installation de W4 BPMN+.
Exemple :
keyPairGenerator.bat -kpa DSA -s 1024 -pvf private.txt -pbf public.txt
Deux fichiers txt sont ainsi créés, le premier pour la clé privée, précédé par l’argument
-pvf, et le second pour la clé publique, précédé par l’argument -pbf.
Dans la ligne de commande ci-dessus, les fichiers private.txt et public.txt sont créés dans
le dossier tools/keyPairGenerator du répertoire d’installation de W4 BPMN+.
1.1.2
Attribution de la clé publique aux utilisateurs concernés
Via W4 BPMN+ Admin, vous devez créer une clé publique en précisant le fichier de clé
publique créé par le programme keyPairGenerator, par exemple public.txt dans l’exemple
ci-dessus.
Pour plus d’informations, veuillez consulter le chapitre Administration des utilisateurs et
des groupes du document Administration avec W4 BPMN+ Admin (section Ajout de clés
publiques).
Vous devez ensuite, toujours via W4 BPMN+ Admin, attribuer la clé publique aux
utilisateurs concernés.
1.1.3
Récupération de l’utilisateur connecté
Il existe deux possibilités :
 Soit l’utilisateur est dans remote_user, et aucune action n’est nécessaire.
 Dans le cas contraire il est nécessaire de coder la récupération de l’utilisateur en
spécifique dans la méthode getUserFromLogin du RootSessionBehavior.
Exemple pour test :
return super.getUserFromLogin(session, "myLogin");
1.1.4
Positionnement des clés publique et privée dans le fichier ini
Les clés suivantes doivent être valorisées dans le fichier ini de l’application :
 BPMN_PRIVATE_KEY_FILE - Le chemin du fichier de clé privée créé par le programme
keyPairGenerator, soit private.txt dans l’exemple ci-dessus.
 BPMN_PUBLIC_KEY_NAME - Le nom de la clé publique créée dans W4 BPMN+ Admin.
 BPMN_PUBLIC_KEY_PREFIX - Le préfixe de la clé publique créée dans W4 BPMN+ Admin.
Exemple :
BPMN_PRIVATE_KEY_FILE=C:/BPMN_plus/tools/keyPairGenerator/ACE_private.txt
BPMN_PUBLIC_KEY_NAME=ACE
BPMN_PUBLIC_KEY_PREFIX=ACE
Note technique - Mise en œuvre du SSO par clés publiques et privées
3
4
body
1.2
Exemple de code
[TN]
3
private static final KeyFactory _keyFactory;
static
{
try
{
}
_keyFactory = KeyFactory.getInstance("DSA");
catch (final Exception exception)
{
}
throw new RuntimeException(exception.getMessage(), exception);
}
private static byte[] loadResource(final String resource) throws Exception
{
final InputStream inputStream = ClassLoader.getSystemResourceAsStream(resource);
if (inputStream == null)
{
}
throw new Exception("Resource [" + resource + "] was not found");
byte[] content = new byte[0];
final byte[] buffer = new byte[10240];
try
{
int readedBytes;
while ((readedBytes = inputStream.read(buffer)) != -1)
{
}
final byte[] tmp = content;
content = new byte[tmp.length + readedBytes];
System.arraycopy(tmp, 0, content, 0, tmp.length);
System.arraycopy(buffer, 0, content, tmp.length, readedBytes);
}
finally
{
}
}
inputStream.close();
return content;
private static PublicKey loadPublicKey(final String resourceName) throws Exception
{
}
final byte[] publicKeyData = loadResource(resourceName);
final EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(publicKeyData);
return _keyFactory.generatePublic(publicKeySpec);
private static PrivateKey loadPrivateKey(final String resourceName) throws Exception
{
final byte[] privateKeyData = loadResource(resourceName);
final EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(privateKeyData);
return _keyFactory.generatePrivate(privateKeySpec);
}
// ***** Ajout d’une clé à l’utilisateur *****
final PublicKeyService publicKeyService = engineService.getPublicKeyService();
// Chargement de la clé publique
final PublicKey publicKey = loadPublicKey(DEFAULT_PUBLIC_KEY);
final PublicKeyDefinitionIdentifier keyDefinitionIdentifier =
publicKeyService.createPublicKeyDefinition(adminPrincipal,
prefix,
keyName,
publicKey);
// Attribution de la clé à l’utilisateur
userService.addUserPublicKeyDefinition(adminPrincipal, userIdentifier,
keyDefinitionIdentifier);
// ***** LE CODE D’AUTHENTIFICATION *****
// Authentification en deux phases
// Demande de challenge
final byte[] challenge = authenticationService.createRandomChallenge(userName,
keyDefinitionIdentifier);
// Encodage du challenge à l’aide de la clé privée
final PrivateKey privateKey = loadPrivateKey(DEFAULT_PRIVATE_KEY);
final byte[] response = SignatureHelper.sign("SHA1withDSA",
privateKey,
challenge);
// Réponse au challenge
final Principal principal = authenticationService.challengeResponse(keyDefinitionIdentifier,
userName,
response);
Note technique - Mise en œuvre du SSO par clés publiques et privées
5
6
FINAL
body