Sécurité JMX (Java Management Extensions)

Vous pouvez sécuriser les invocations de beans gérés (MBean) dans un environnement réparti.

Pour plus d'informations sur les beans gérés disponibles, voir Administration avec les beans gérés (MBeans).

Dans une topologie de déploiement réparti, les beans gérés sont directement hébergés sur les serveurs de catalogue et les serveurs de conteneur. En général, la sécurité JMX dans une topologie répartie suit la spécification de sécurité JMX telle que spécifiée dans la spécification JMX (Java Management Extensions). Elle est composée des trois parties suivantes :
  1. Authentification : le client distant doit être authentifié dans le serveur de connecteur.
  2. Contrôle d'accès : le contrôle de l'accès des beans gérés définit les privilèges d'accès aux informations de beans gérés et les droits d'exécution des opérations de beans gérés.
  3. Transfert sécurisé : le transfert entre le client et le serveur JMX peut être sécurisé à l'aide du protocole TLS/SSL.

Authentification

JMX offre des méthodes aux serveurs de connecteur pour authentifier les clients distants. Pour le connecteur RMI, l'authentification est effectuée en fournissant un objet qui implémente l'interface JMXAuthenticator lors de la création du serveur de connecteur. Par conséquent, eXtreme Scale implémente cette interface JMXAuthenticator à utiliser le plug-in ObjectGrid Authenticator pour authentifier les clients distants. Voir Tutoriel sur la sécurité Java SE - Etape 2 pour plus de détails sur l'authentification d'un client par eXtreme Scale.

Le client JMX suit les API JMX pour offrir des données d'identification permettant la connexion au serveur de connecteur. L'infrastructure JMX transmet les données d'identification au serveur de connecteur et appelle l'implémentation JMXAuthenticator pour l'authentification. Comme décrit précédemment, l'implémentation JMXAuthenticator délègue ensuite l'authentification à l'implémentation de l'authentificateur ObjectGrid.

Passez en revue l'exemple présenté ci-dessous, qui décrit comment établir la connexion à un serveur de connecteur à l'aide de données d'identification :

javax.management.remote.JMXServiceURL jmxUrl = new JMXServiceURL(
        "service:jmx:rmi:///jndi/rmi://localhost:1099/objectgrid/MBeanServer");

    environment.put(JMXConnector.CREDENTIALS, new UserPasswordCredential("admin", "xxxxxx"));

    // Créez le JMXCconnectorServer
    JMXConnector cntor = JMXConnectorFactory.newJMXConnector(jmxUrl, null);

    // Connectez et appelez une opération sur le MBeanServer distant
    cntor.connect(environment);

Dans l'exemple précédent, un objet UserPasswordCredential est fourni avec l'ID utilisateur admin et le mot de passe xxxxx. Cet objet UserPasswordCredential est défini dans la mappe d'environnement qui est utilisée dans la méthode JMXConnector.connect(Map). Cet objet UserPasswordCredential est ensuite transmis au serveur par l'infrastructure JMX, puis à l'infrastructure d'authentification ObjectGrid pour authentification.

Le modèle de programmation client respecte strictement les spécifications JMX.

Contrôle d'accès

Un serveur de beans gérés JMX peut avoir accès aux informations sensibles et peut être en mesure d'effectuer des opérations sensibles. JMX offre le contrôle d'accès requis permettant d'identifier les clients pouvant accéder à telles ou telles informations et qui peut effectuer ces opérations. Le contrôle d'accès repose sur le modèle de sécurité Java standard en définissant des autorisations de contrôle d'accès au serveur de beans gérés et aux opérations correspondantes.

Pour le contrôle d'accès ou l'autorisation des opérations JMX, eXtreme Scale repose sur le support JAAS fourni par l'implémentation JMX. A n'importe quel stade de l'exécution d'un programme, il existe un ensemble d'autorisations maintenu dans une unité d'exécution. Lorsqu'une unité d'exécution appelle une opération de spécification JMX, ces autorisations sont connues sous le terme d'autorisations de maintien. Lorsqu'une opération JMX est effectuée, une vérification de sécurité est réalisée pour vérifier si l'autorisation requise est concernée par l'autorisation de maintien.

La définition des règles d'administration de beans gérés respecte le format de la stratégie Java. Par exemple, la stratégie suivante octroie à tous les signataires et bases de code le droit d'extraire l'adresse JMX du serveur pour PlacementServiceMBean avec une restriction pour le domaine com.ibm.websphere.objectgrid domain.

grant {
    permission javax.management.MBeanPermission
        "com.ibm.websphere.objectgrid.management.PlacementServiceMBean#retrieveServerJMXAddress 
					[com.ibm.websphere.objectgrid:*,type=PlacementService]",
        "invoke";
}

Vous pouvez utiliser l'exemple de stratégie suivant pour compléter l'autorisation en fonction de l'identité du client distant. La stratégie octroie la même autorisation de bean géré que celle présentée dans l'exemple précédent, sauf pour les utilisateurs dont le nom X500Principal est : CN=Administrator,OU=software,O=IBM,L=Rochester,ST=MN,C=US.

grant principal javax.security.auth.x500.X500Principal "CN=Administrator,OU=software,O=IBM,
				L=Rochester,ST=MN,C=US" {permission javax.management.MBeanPermission
        "com.ibm.websphere.objectgrid.management.PlacementServiceMBean#retrieveServerJMXAddress 
				[com.ibm.websphere.objectgrid:*,type=PlacementService]",
        "invoke";
}

Les stratégies Java sont uniquement vérifiées si le gestionnaire de sécurité est activé. Démarrez les serveurs de catalogue et les serveurs de conteneur à l'aide de l'argument JVM -Djava.security.manager pour forcer le contrôle d'accès des opérations de beans gérés.

Transfert sécurisé

Le transfert entre le client et le serveur JMX peut être sécurisé à l'aide du protocole TLS/SSL. Si le type de transfert du serveur de catalogues ou du serveur conteneur est défini sur SSL_Required ou SSL_Supported, vous devez utiliser le protocole SSL pour établir la connexion au serveur JMX.

Pour utiliser le protocole SSL, vous devez configurer le fichier de clés certifiées, le type de fichier de clés certifiées et le mot de passe du fichier de clés certifiées sur le client MBean en utilisant les propriétés système -D :
  1. -Djavax.net.ssl.trustStore=TRUST_STORE_LOCATION
  2. -Djavax.net.ssl.trustStorePassword=TRUST_STORE_PASSWORD
  3. -Djavax.net.ssl.trustStoreType=TRUST_STORE_TYPE
Si vous utilisez com.ibm.websphere.ssl.protocol.SSLSocketFactory comme fabrique de sockets SSL dans le fichierrép_base_java/jre/lib/security/java.security, utilisez les propriétés suivantes :
  1. -Dcom.ibm.ssl.trustStore=TRUST_STORE_LOCATION
  2. -Dcom.ibm.ssl.trustStorePassword=TRUST_STORE_PASSWORD
  3. -Dcom.ibm.ssl.trustStoreType=TRUST_STORE_TYPE
Pour obtenir ces informations lorsque le protocole TLS/SSL (Transport Layer Security/Secure Sockets Layer) est activé dans des configurations autonomes, vous devez démarrer les serveurs de catalogue et de conteneur avec l'ensemble de ports de service JMX. Utilisez l'une des méthodes suivantes pour configurer le port de service JMX :
  • Utilisez l'option -JMXServicePort sur le script startOgServer.
  • Si vous utilisez un serveur embarqué, appelez la méthode setJMXServicePort dans l'interface ServerProperties pour définir le port de service JMX.
La valeur par défaut du port de service JMX sur les serveurs de catalogue est 1099. Vous devez utiliser un numéro de port différent pour chaque machine virtuelle Java dans votre configuration. Si vous souhaitez utiliser JMX/RMI, vous devez spécifier explicitement l'option -JMXServicePort et le numéro de port, même si vous souhaitez utiliser la valeur de port par défaut.

Vous devez définir le port de service JMX si vous souhaitez afficher les informations du serveur de conteneur à partir du serveur de catalogue. Par exemple, le port est requis lorsque vous utilisez la commande xscmd -c showMapSizes.

Définissez le port de connecteur JMX afin d'éviter la création d'un port éphémère. Utilisez l'une des méthodes suivantes pour configurer le port de connecteur JMX.
  • Utilisez l'option -JMXConnectorPort dans le script startOgServer.
  • Si vous utilisez un serveur embarqué, appelez la méthode setJMVConnectorPort dans l'interface ServerProperties.