Développement d'un fournisseur customPasswordEncryption

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

  1. 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) {}
    
    }
  2. 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>
  3. 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
  4. 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.

  5. 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 customPassworedEncryptionOrganigramme montrant la relation des fichiers et de leurs répertoires.
  6. 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.


Icône indiquant le type de rubrique Rubrique Tâche

Nom du fichier : twlp_developing_custom_passwd_encrypt.html