Vous pouvez développer un fournisseur customPasswordEncryption afin de
disposer de
décisions d'autorisation personnalisées pour les applications Java™ Platform, Enterprise Edition
(J2EE) en implémentant l'interface com.ibm.wsspi.security.crypto.CustomPasswordEncryption qui est fournie dans le serveur Liberty.
Pourquoi et quand exécuter cette tâche
Remarque : Les étapes facultatives suivantes permettent de prendre en charge les utilitaires de la ligne de commande. Si le fournisseur tente uniquement de prendre en charge l'environnement
d'exécution du serveur, ces étapes peuvent être ignorées.
Le fournisseur
customPassworedEncryption comprend les trois fichiers suivants :
- Le fichier bundle OSGi, qui contient le fichier exécutable.
- Le fichier manifeste de fonction qui définit la fonction utilisateur du fournisseur customPasswordEncryption. Ce fichier contient l'emplacement des bundles et des
attributs requis de la fonction et le fichier manifeste d'extension s'il est conditionné. Ces informations sont consommées par l'environnement d'exécution du serveur.
- Le fichier manifeste d'extension, qui définit les fichiers de bundle requis et le nom de la classe d'implémentation du fournisseur customPasswordEncryption. Ce fichier est
facultatif et il est requis pour prendre en charge les utilitaires de la ligne de commande.
Procédure
- Créez un composant OSGi qui fournit un service qui implémente l'interface com.ibm.wsspi.security.crypto.CustomPasswordEncryption.
L'interface CustomPasswordEncryption définit trois méthodes, decrypt, que l'environnement
d'exécution du serveur Liberty appelle pour déchiffrer la chaîne, encrypt, que l'environnement
d'exécution du serveur Liberty appelle pour chiffrer la chaîne et initialize, qui est réservé pour un usage ultérieur.
L'exemple suivant utilise les annotations de services déclaratifs
OSGi :
package com.mycompany.custom;
import org.osgi.service.component.ComponentContext;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.ConfigurationPolicy;
import org.osgi.service.component.annotations.Deactivate;
import org.osgi.service.component.annotations.Modified;
import com.ibm.wsspi.security.crypto.CustomPasswordEncryption;
import com.ibm.wsspi.security.crypto.EncryptedInfo;
import com.ibm.wsspi.security.crypto.PasswordDecryptException;
import com.ibm.wsspi.security.crypto.PasswordEncryptException;
/**
*/
@Component(service = CustomPasswordEncryption.class,
immediate = true,
name = "com.mycompany.CustomPasswordEncryptionImpl",
configurationPolicy = ConfigurationPolicy.OPTIONAL,
property = { "someKey=someValue" })
public class CustomPasswordEncryptionImpl implements CustomPasswordEncryption {
@Activate
protected synchronized void activate(ComponentContext cc, Map<String, Object> props) {
}
@Modified
protected synchronized void modify(Map<String, Object> props) {
}
@Deactivate
protected void deactivate(ComponentContext cc) {
}
/**
* The encrypt operation takes a UTF-8 encoded String in the form of a byte[].
* The byte[] is generated from String.getBytes("UTF-8"). An encrypted byte[]
* is returned from the implementation in the EncryptedInfo object.
* Additionally, a logically key alias is returned in EncryptedInfo so which
* is passed back into the decrypt method to determine which key was used to
* encrypt this password. The WebSphere Application Server runtime has no
* knowledge of the algorithm or key used to encrypt the data.
*
* @param decrypted_bytes
* @return com.ibm.wsspi.security.crypto.EncryptedInfo
* @throws com.ibm.wsspi.security.crypto.PasswordEncryptException
**/
@Override
public EncryptedInfo encrypt(byte[] input) throws PasswordEncryptException {
byte[] output = null;
String key = null;
try {
:
<do some encryption>
:
return new EncryptedInfo(output, key);
} catch (Exception e) {
throw new PasswordEncryptException("Exception is caught", e);
}
}
/**
* The decrypt operation takes the EncryptedInfo object containing a byte[]
* and the logical key alias and converts it to the decrypted byte[]. The
* WebSphere Application Server runtime will convert the byte[] to a String
* using new String (byte[], "UTF-8");
*
* @param info
* @return byte[]
* @throws PasswordEncryptException
* @throws com.ibm.wsspi.security.crypto.PasswordDecryptException
**/
@Override
public byte[] decrypt(EncryptedInfo info) throws PasswordDecryptException {
byte[] input = info.getEncryptedBytes();
String key = info.getKeyAlias();
byte[] output = null;
try {
:
<do some decryption>
:
return output;
} catch (Exception e) {
throw new PasswordEncryptException("Exception is caught", e);
}
}
/**
* This is reserved for future use and is currently not called by the
* WebSphere Application Server runtime.
*
* @param initialization_data
**/
@SuppressWarnings("rawtypes")
@Override
public void initialize(Map initialization_data) {}
}
- Packagez le composant dans un bundle OSGi qui fait partie de votre fonction utilisateur. Vérifiez que le bundle comprend le manifeste de service OSGi.
L'exemple ci-après illustre le contenu du manifeste de service OSGi :
<?xml version="1.0" encoding="UTF-8"?>
<scr:component xmlns:scr="http://www.osgi.org/xmlns/scr/v1.1.0" name="com.mycompany.custom.CustomPasswordEncryptionImpl" configuration-policy="optional" immediate="true" activate="activate" deactivate="deactivate" modified="modify">
<implementation class="com.mycompany.custom.CusomPasswordEncryptionImpl"/>
<service>
<provide interface="com.ibm.wsspi.security.crypto.CustomPasswordEncryption"/>
</service>
<property name="<someKey>" type="String" value="<someValue>"/>
</scr:component>
- Vérifiez que votre fichier manifeste de fonction inclut le contenu du sous-système OSGi avec start-phase:="SERVICE_EARLY". Si l'étape facultative est exécutée,
l'emplacement du fichier manifeste d'extension est indiqué dans l'en-tête Subsystem-Content. Exemple :
Manifest-Version: 1.0
IBM-Feature-Version: 2
IBM-ShortName: customPasswordEncryption-1.0
Subsystem-Type: osgi.subsystem.feature
Subsystem-Version: 1.0.0
Subsystem-ManifestVersion: 1.0
Subsystem-SymbolicName: customPasswordEncryption-1.0;visibility:=public
Subsystem-Content:
com.mycompany.custom; version="[1,1.0.100)"; start-phase:="SERVICE_EARLY", customEncryption.jar; type=file; \
location:="bin/tools/extensions/ws-customPasswordEncryption/customEncryption.jar”
Subsystem-Description: MyCompany custom password encryption
- Une fois la fonction installée dans l'emplacement
d'extension de produit utilisateur, configurez le fichier
server.xml avec le nom de la fonction.
<featureManager>
...
<feature>usr:customPasswordEncryption-1.0</feature>
</featureManager>
Pour vérifier que l'installation a abouti pour l'environnement d'exécution du serveur, vérifiez que le message CWWKS1850I est consigné dans le fichier message.log.
- Facultatif : Créez le fichier manifeste d'extension qui est requis pour connecter le fournisseur customPasswordEncryption aux utilitaires de la ligne de commande
comme par exemple SecurityUtility. Le fichier manifeste d'extension est un fichier JAR qui contient le fichier MANIFEST.MF. Les en-têtes obligatoires du
manifeste d'extension sont :
- Require-Bundle : Définit la liste des bundles qui doit être chargée. Le format est le même que le fichier manifeste de bundle OSGi.
- IBM-ImplementationClass : Définit la classe d'implémentation qui implémente l'interface com.ibm.wsspi.security.crypto.CustomPasswordEncryption.
Ci-après, un exemple de fichier MANIFEST.MF
Require-Bundle: com.mycompany.custom; version="[1,1.0.100)"; location="usr/extension/lib"
IBM-ImplementationClass: com.mycompany.custom.CusomPasswordEncryptionImpl
Utilisez la commande
jar pour conditionner le fichier manifeste d'extension. Exemple :
jar cfm customEncryption.jar MANIFEST.MF
Placez le fichier JAR dans wlp/bin/tools/extensions/ws-customPasswordEncryption.
Vérifiez que l'emplacement du fichier manifeste d'extension se trouve dans la section d'en-tête Subsystem-Content du fichier manifeste de fonction.
Ces fichiers doivent se trouver dans des répertoires spécifiques. La relation entre les fichiers est la suivante :
Figure 1. Fichiers du fournisseur customPassworedEncryption
- Facultatif : si l'étape 5 est terminée, vous pouvez vérifier que l'installation a réussi en utilisant la commande suivante de l'utilitaire de ligne de commande
wlp/bin/securityUtility encode --listCustom
La sortie attendue est l'information de
customPasswordEncryption. Exemple :
[{"name":"custom","featurename":"usr:customPasswordEncryption-1.0","description":"MyCompany custom password encryption"}]
Vérifiez que toues les fichiers requis existent et que le contenu des fichiers est correct.