JMSWMQ2013: The security authentication was not valid that was supplied for queue manager 'QM1'

Viewed 3889

Any help or hint would be greatly appreciated it. My ibm mq is running on dockers. I logged into the console using the following id and password:

https://localhost:9443/ibmmq/console
id:admin
password:passw0rd

In the java code below I used the same id and password. The "DEV.QUEUE.1" exist(please see image below).

com.ibm.msg.client.jms.DetailedJMSSecurityRuntimeException: JMSWMQ2013: The security authentication was not valid that was supplied for queue manager 'QM1' with connection mode 'Client' and host name 'localhost(1414)'.
Please check if the supplied username and password are correct on the queue manager to which you are connecting.  For further information, review the queue manager error logs and the Securing IBM MQ topic within IBM Knowledge Center. 
                /*
            * (c) Copyright IBM Corporation 2018
            *
            * Licensed under the Apache License, Version 2.0 (the "License");
            * you may not use this file except in compliance with the License.
            * You may obtain a copy of the License at
            *
            * http://www.apache.org/licenses/LICENSE-2.0
            *
            * Unless required by applicable law or agreed to in writing, software
            * distributed under the License is distributed on an "AS IS" BASIS,
            * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
            * See the License for the specific language governing permissions and
            * limitations under the License.
            */

            package com.ibm.mq.samples.jms;


            import javax.jms.Destination;
            import javax.jms.JMSConsumer;
            import javax.jms.JMSContext;
            import javax.jms.JMSException;
            import javax.jms.JMSProducer;
            import javax.jms.TextMessage;

            import com.ibm.msg.client.jms.JmsConnectionFactory;
            import com.ibm.msg.client.jms.JmsFactoryFactory;
            import com.ibm.msg.client.wmq.WMQConstants;

            /**
             * A minimal and simple application for Point-to-point messaging.
             *
             * Application makes use of fixed literals, any customisations will require
             * re-compilation of this source file. Application assumes that the named queue
             * is empty prior to a run.
             *
             * Notes:
             *
             * API type: JMS API (v2.0, simplified domain)
             *
             * Messaging domain: Point-to-point
             *
             * Provider type: IBM MQ
             *
             * Connection mode: Client connection
             *
             * JNDI in use: No
             *
             */
            public class JmsPutGet {

                // System exit status value (assume unset value to be 1)
                private static int status = 1;

                // Create variables for the connection to MQ
                private static final String HOST = "localhost"; // Host name or IP address
                private static final int PORT = 1414; // Listener port for your queue manager
                private static final String CHANNEL = "DEV.APP.SVRCONN"; // Channel name
                private static final String QMGR = "QM1"; // Queue manager name
                private static final String APP_USER = "admin"; // User name that application uses to connect to MQ
                private static final String APP_PASSWORD = "passw0rd"; // Password that the application uses to connect to MQ
                private static final String QUEUE_NAME = "DEV.QUEUE.1"; // Queue that the application uses to put and get messages to and from


                /**
                 * Main method
                 *
                 * @param args
                 */
                public static void main(String[] args) {

                    // Variables
                    JMSContext context = null;
                    Destination destination = null;
                    JMSProducer producer = null;
                    JMSConsumer consumer = null;



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

                        // Set the properties
                        cf.setStringProperty(WMQConstants.WMQ_HOST_NAME, HOST);
                        cf.setIntProperty(WMQConstants.WMQ_PORT, PORT);
                        cf.setStringProperty(WMQConstants.WMQ_CHANNEL, CHANNEL);
                        cf.setIntProperty(WMQConstants.WMQ_CONNECTION_MODE, WMQConstants.WMQ_CM_CLIENT);
                        cf.setStringProperty(WMQConstants.WMQ_QUEUE_MANAGER, QMGR);
                        cf.setStringProperty(WMQConstants.WMQ_APPLICATIONNAME, "JmsPutGet (JMS)");
                        cf.setBooleanProperty(WMQConstants.USER_AUTHENTICATION_MQCSP, true);
                        cf.setStringProperty(WMQConstants.USERID, APP_USER);
                        cf.setStringProperty(WMQConstants.PASSWORD, APP_PASSWORD);
                        //cf.setStringProperty(WMQConstants.WMQ_SSL_CIPHER_SUITE, "*TLS12");

                        // Create JMS objects
                        context = cf.createContext();
                        destination = context.createQueue("queue:///" + QUEUE_NAME);

                        long uniqueNumber = System.currentTimeMillis() % 1000;
                        TextMessage message = context.createTextMessage("Your lucky number today is " + uniqueNumber);

                        producer = context.createProducer();
                        producer.send(destination, message);
                        System.out.println("Sent message:\n" + message);

                        consumer = context.createConsumer(destination); // autoclosable
                        String receivedMessage = consumer.receiveBody(String.class, 15000); // in ms or 15 seconds

                        System.out.println("\nReceived message:\n" + receivedMessage);

                        context.close();

                        recordSuccess();
                    } catch (JMSException jmsex) {
                        recordFailure(jmsex);
                    }
                    catch(Exception e) {
                        System.out.println("exception:"+e.getMessage());
                    }

                    System.exit(status);

                } // end main()

                /**
                 * Record this run as successful.
                 */
                private static void recordSuccess() {
                    System.out.println("SUCCESS");
                    status = 0;
                    return;
                }

                /**
                 * Record this run as failure.
                 *
                 * @param ex
                 */
                private static void recordFailure(Exception ex) {
                    if (ex != null) {
                        if (ex instanceof JMSException) {
                            processJMSException((JMSException) ex);
                        } else {
                            System.out.println(ex);
                        }
                    }
                    System.out.println("FAILURE");
                    status = -1;
                    return;
                }

                /**
                 * Process a JMSException and any associated inner exceptions.
                 *
                 * @param jmsex
                 */
                private static void processJMSException(JMSException jmsex) {
                    System.out.println(jmsex);
                    Throwable innerException = jmsex.getLinkedException();
                    if (innerException != null) {
                        System.out.println("Inner exception(s):");
                    }
                    while (innerException != null) {
                        System.out.println(innerException);
                        innerException = innerException.getCause();
                    }
                    return;
                }

            }

enter image description here


Update

Commented out these two lines:

cf.setStringProperty(WMQConstants.USERID, APP_USER);
cf.setStringProperty(WMQConstants.PASSWORD, APP_PASSWORD);

Outcome:

Sent message:

  JMSMessage class: jms_text
  JMSType:          null
  JMSDeliveryMode:  2
  JMSDeliveryDelay: 0
  JMSDeliveryTime:  1626132731104
  JMSExpiration:    0
  JMSPriority:      4
  JMSMessageID:     ID:414d5120514d312020202020202020203c98ea6001540140
  JMSTimestamp:     1626132731104
  JMSCorrelationID: null
  JMSDestination:   queue:///DEV.QUEUE.1
  JMSReplyTo:       null
  JMSRedelivered:   false
    JMSXAppID: JmsPutGet (JMS)             
    JMSXDeliveryCount: 0
    JMSXUserID: app         
    JMS_IBM_PutApplType: 28
    JMS_IBM_PutDate: 20210712
    JMS_IBM_PutTime: 23321072
Your lucky number today is 837

Received message:
Your lucky number today is 837
SUCCESS

enter image description here

1 Answers

For channel DEV.APP.SVRCONN and QMgr QM1 authorisation is disabled by default.

Try to remove APP_USER and APP_PASSWORD. Notice: admin and passw0rd are only for admin console.

Or see my this answer and disable authorisation: IBM MQ authentication

Related