Configurando uma instância personalizada do SSLSocketFactory para recuperação de JWT

A partir de IBM® MQ 9.4.5, você pode fornecer uma instância personalizada do SSLSocketFactory para controlar como seu aplicativo recupera com segurança tokens JWT de pontos de extremidade HTTPS. Este SSLSocketFactory personalizado também pode especificar o nível de validação que a biblioteca IBM MQ classes for JMS cliente executa quando recupera o JWT de uma conexão HTTPS. Você pode escolher se o cliente precisa de validação completa, se pode ignorar as verificações do nome do host ou se não deve realizar a validação do certificado.

Sobre esta tarefa

Se um IBM MQ classes for JMS cliente depende das configurações SSL da JVM para recuperar tokens de um endpoint de token HTTPS, isso impede que você isole o tratamento de certificados para o endpoint do token. Se uma instância personalizada do SSLSocketFactory for fornecida, ela substituirá o comportamento padrão das configurações SSL da JVM. Ao usar a TOKEN_SSL_SOCKET_FACTORY propriedade para fornecer uma instância separada e personalizada do SSLSocketFactory na IBM MQ classes for JMS biblioteca para recuperação de JWT de um endpoint HTTPS, você pode definir o truststore usado pelo seu JMS aplicativo, evitar depender das configurações padrão de SSL da JVM e personalizar o tratamento de HTTPS sem afetar os outros aplicativos que estão sendo executados na mesma JVM.

A instância do SSLSocketFactory que você deseja que a conexão do servidor de token JWT use pode ser diferente daquela que você usa para o gerenciador de filas ou suas conexões CCDT.

A validação do certificado é tratada de acordo com a lógica definida na fábrica personalizada. Os aplicativos podem especificar o nível de validação aplicado durante uma conexã HTTPS, usando a propriedade de política TOKEN_HTTPS_CERT_VALIDATION_POLICY de validação de certificado e especificando a opção necessária, que pode ser QUALQUER, HOSTNAMECN (padrão) ou NENHUMA. Para obter mais informações, consulte Configurando políticas de validação de certificados em IBM MQ.

Se a política de validação de certificados estiver definida como NENHUMA, o aplicativo usa a implementação do manipulador fornecida pela IBM MQ classes for JMS biblioteca, HttpsSSLHandler que confia em todos os certificados. Esta implementação do manipulador é substituída pelo fornecimento de um manipulador de conexão personalizado ( SSLSocketFactory ) que se aplica a todas as conexões JWT ( HTTPS ).

Se nenhuma instância personalizada do SSLSocketFactory for fornecida, o sistema utilizará por padrão o mecanismo interno de Java Secure Socket Extensionvalidação de certificados 's (JSSE).

Procedimento

Crie e personalize as lojas.
A aplicação começa criando um SSLContext e, em seguida, obtendo um SSLSocketFactory a partir dele.
Esta fábrica será posteriormente atribuída à conexão JWT HTTPS.
Crie a fábrica IBM MQ classes for JMS de conexões.
Isso JmsConnectionFactory é configurado com propriedades de autenticação e SSL.
Defina o gerenciador de fila.
Isso identifica a qual gerenciador de filas o cliente se conectará após a recuperação do token.
Configure os parâmetros JWT.
Essas propriedades instruem o cliente sobre como obter um token JWT.
TOKEN_CLIENT_ID e TOKEN_CLIENT_SECRET defina as credenciais OAuth.
TOKEN_ENDPOINT especifica o endpoint HTTPS usado para recuperação de token.
Atribua o SSLSocketFactory personalizado especificamente para a recuperação de JWT HTTPS.
Verifique se apenas a conexão HTTPS com o TOKEN_ENDPOINT usa este SSLSocketFactory e se isso não afeta as configurações SSL em toda a JVM.
Configure as políticas de validação de certificados.
Se o valor da política for NONE, isso controla a verificação do nome do host e do certificado para as conexões HTTPS quando um SSLSocketFactory personalizado não substitui o comportamento da certificação. Para ANY e HOSTNAMECN, a política se aplica independentemente da presença personalizada de SSLSocketFactory's.
Crie os JMS objetos e inicie a conexão.
O aplicativo agora está autenticado e pronto para enviar ou receber mensagens.

exemplo

O exemplo a seguir mostra como configurar uma instância personalizada do SSLSocketFactory para os pontos de extremidade HTTPS do token JWT.

Observação: este exemplo demonstra uma implementação básica de SSLSocketFactory com locais de armazenamento de chaves e armazenamento confiável. Modifique-o de acordo com as necessidades do seu ambiente de produção.

public static void main(String[] args) {
  Connection connection = null;
  Session session = null;
  Destination destination = null;
  MessageProducer producer = null;

  // Construct and customize stores 
  SSLContext sslContext = createSimpleSSLContext(); // Check method definition below
  SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();

  // Create a connection factory
  JmsFactoryFactory ff = JmsFactoryFactory.getInstance(WMQConstants.WMQ_PROVIDER);
  JmsConnectionFactory cf = ff.createConnectionFactory();

  // Set the queue manager name
  cf.setStringProperty(WMQConstants.WMQ_QUEUE_MANAGER, "QM1");
  
  // Set properties to get tokens
  cf.setStringProperty(WMQConstants.TOKEN_CLIENT_ID, "mykeycloakclient");
  cf.setStringProperty(WMQConstants.TOKEN_CLIENT_SECRET, "mykeycloaksecret");
  cf.setStringProperty(WMQConstants.TOKEN_ENDPOINT, "https://mykeycloak.server/oidc/token");

  // Set a custom sslSocketFactory instance for the https endpoint set in TOKEN_ENDPOINT property above
  cf.setObjectProperty(WMQConstants.TOKEN_SSL_SOCKET_FACTORY, sslSocketFactory);

  // Set a level of certificate validation
  cf.setIntProperty(WMQConstants.TOKEN_HTTPS_CERT_VALIDATION_POLICY, MQConstants.MQ_HTTPSCERTVAL_ANY);

  // Create JMS objects
  connection = cf.createConnection();
  session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
  destination = session.createQueue("dev.queue.1");
  producer = session.createProducer(destination);

  // Start the connection
  connection.start();
}

// Sample method that constructs keystore and truststore
public static SSLContext createSimpleSSLContext() {
    try {
      KeyStore keyStore = KeyStore.getInstance("JKS");
      try (FileInputStream keyStoreStream = new FileInputStream("clientkey.jks")) {  // Path to keystore jks
        keyStore.load(keyStoreStream, "keystorepassword".toCharArray()); // Hardcoded password just for the sample
      }
      KeyStore trustStore = KeyStore.getInstance("JKS");
      try (FileInputStream trustStoreStream = new FileInputStream("clientkey.jks")) { // Path to truststore jks
        trustStore.load(trustStoreStream, "truststorepassword".toCharArray()); // Hardcoded password just for the sample
      }

      KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
      kmf.init(keyStore, "keystorepassword".toCharArray()); // Hardcoded password just for the sample

      TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
      tmf.init(trustStore);

      SSLContext context = SSLContext.getInstance("TLS"); // set protocol name 
      context.init(kmf.getKeyManagers(), tmf.getTrustManagers(), new SecureRandom());
      return context;
    } catch (Exception e) {
      // handle exception
    }
    return null;
  }