EMQX SSL双向认证配置与编码实现【JAVA】
EMQX SSL双向认证配置与mqtt.fx客户端验证【仅供参考】
一准备工作
yum install openssl
yum install vim
在opt目录下创建ssl目录用来临时存储生成的证书文件
mkdir /opt/ssl
cd /opt/ssl/
cp /etc/pki/tls/openssl.cnf ./
rm -rf /etc/pki/CA/*.old
生成证书索引库数据库文件
touch /etc/pki/CA/index.txt
指定第一个颁发证书的序列号
echo 01 > /etc/pki/CA/serial
证书生成
方法一【这个是我这边测试，服务器与安卓客户端都可用的一种】
CA证书的生成
openssl req -x509 -new -days 3650 -keyout ca.key -out rootCA.crt -nodes
参数:
Country Name (2 letter code) [XX]:国家【中国---CN】
State or Province Name (full name) []:省份
Locality Name (eg, city) [Default City]:城市
Organization Name (eg, company) [Default Company Ltd]:组织名称
Organizational Unit Name (eg, section) []:组织单元名称
Common Name (eg, your name or your server's hostname) []:服务器IP
Email Address []: 邮箱地址
为server端生成证书
一、生成私钥
openssl genrsa -out server.key 2048
二、生成证书请求csr文件
openssl req -new -key server.key -out server.csr
参数填写与前面类似
A challenge password []: 密码
An optional company name []:公司名称
三、生成证书
openssl ca -in server.csr -out server.crt -cert rootCA.crt -keyfile ca.key -days 3650
为Client端生成证书
一、生成私钥：
openssl genrsa -out client.key 2048
二、生成证书请求:
openssl req -new -key client.key -out client.csr
参数与服务端证书生成类似，不过这里我用到ip是客户端ip
三、生成证书
openssl ca -in client.csr -out client.crt -cert rootCA.crt -keyfile ca.key
修改emqx/etc/emqx.conf配置文件
将生成的CA文件复制到/opt/emqx/etc/certs目录下
listener.ssl.external.keyfile = /opt/emqx/etc/certs/server.key
listener.ssl.external.certfile = /opt/emqx/etc/certs/server.crt
listener.ssl.external.cacertfile = /opt/emqx/etc/certs/rootCA.crt
listener.ssl.external.verify = verify_peer
listener.ssl.external.fail_if_no_peer_cert = true
方法二【并非所有场景都适合】
生成CA key和证书（为了方便我这里客户端与服务器共用一个）
生成CA key【采用2048字节】
openssl genrsa -out ca.key 2048
生成CA 证书【默认3650天】
openssl req -x509 -new -nodes -key ca.key -sha256 -days 3650 -subj "/CN=www.emqx.io" -out ca.pem
生成服务端key和证书
openssl genrsa -out server.key 2048
注意将IP修改为服务器IP
openssl req -new -key ./server.key -out server.csr -subj "/CN=127.0.0.1"
openssl x509 -req -in ./server.csr -CA ca.pem -CAkey ca.key -CAcreateserial -out server.pem -days 3650 -sha256
生成客户端key和证书
openssl genrsa -out client.key 2048
注意将IP修改为客户端IP
openssl req -new -key ./client.key -out client.csr -subj "/CN=127.0.0.1"
openssl x509 -req -in ./client.csr -CA ca.pem -CAkey ca.key -CAcreateserial -out client.pem -days 3650 -sha256
修改emqx/etc/emqx.conf配置文件
将生成的CA文件复制到/opt/emqx/etc/certs目录下
## SSL Options
listener.ssl.external.handshake_timeout = 15
listener.ssl.external.keyfile = /etc/certs/server.key
listener.ssl.external.certfile = /etc/certs/server.pem
## 开启双向认证
listener.ssl.external.cacertfile = /etc/certs/ca.pem
listener.ssl.external.verify = verify_peer
listener.ssl.external.fail_if_no_peer_cert = true
启用用户名密码验证【可选】
emqx是默认开启匿名认证的，即客户端不需要任何认证信息即可连上emqx服务器，但生产环境这样肯定是不行的。emqx也支持很多种认证方式，这里我选着最简单的一种，用户名密码认证
#先要把emq的匿名认证关了，在emqx.conf文件
allow_anonymous = false
**重启emqx服务**
#加载用户名认证插件
./bin/emqx_ctl plugins load emqx_auth_username
#添加用户
./bin/emqx_ctl users add <Username> <Password>
使用MQTT.fx客户端验证是否配置成功
mqtt.fx下载地址:http://www.jensd.de/apps/mqttfx/
我这里选用的是windows1.7.1的版本
MQTT.fx客户端使用
创建emqx连接
若是启用了 用户名密码 认证，需要在这填写用户名密码信息
配置客户端ssl连接证书（方法一）
配置客户端ssl连接证书（方法二）
连接emqx
发送消息
编码实现
导入MAVEN依赖
<dependency>
<groupId>org.eclipse.paho</groupId>
<artifactId>org.eclipse.paho.client.mqttv3</artifactId>
<version>1.2.0</version>
</dependency>
我这里需要将部分证书文件转换成我所需要的格式备用-【若是有其他的实现，可以不用参考我的】
cd 进入证书所在目录【方法二】
将ca.pem 与 client.pem 转化为.crt格式
openssl x509 -outform der -in your-ca.pem -out your-ca.crt
openssl x509 -outform der -in your-client.pem -out your-client.crt
将client.key转换为.pem文件【方法一、方法二通用，java代码连接需要】
openssl pkcs8 -topk8 -inform PEM -in client.key -outform PEM -nocrypt -out client-key-pkcs8.pem
将crt文件转化为p12 文件 再转换为bks文件 供安卓客户端使用
crt转p12
openssl pkcs12 -export -in client.crt -inkey client.key -out client.p12
p12 转bks
keytool -importkeystore -srckeystore client.p12 -srcstoretype pkcs12 -destkeystore client.bks -deststoretype bks -provider org.bouncycastle.jce.provider.BouncyCastleProvider -providerpath bcprov-ext-jdk15on-157.jar
转换过程输入的密码即为证书创建时输入的密码
若是转换出来的文件不可用，请参考：https://blog.csdn.net/qq_36992688/article/details/78861883
Java代码
MQTT静态常量类
/**
* MQTT静态参数常量类
*/
public class MqttConstant {
//MQTT 服务器基础配置
/**
* MQTT服务器IP、端口
*/
public final static String MQTT_IP_PORT = "ssl://127.0.0.1:8883";
/**
* MQTT服务器登录 用户名 elinker
*/
public final static String MQTT_USERNAME = "username";
/**
* MQTT服务器登录 密码
*/
public final static String MQTT_PASSWORD = "password";
/**
* MQTT客户端【应用程序】 ID【自定义】
*/
public final static String MQTT_CLIENTID = "test";
/**
* MQTT客户端【应用程序】 订阅主题【自定义】
*/
public final static String MQTT_TOPIC = "web/pubClient";
//SSL双向认证 配置文件目录
/**
* CA证书
*/
public final static String SSL_CA_CRT = "ca.crt证书文件路径";
/**
* 客户端证书
*/
public final static String SSL_CLIENT_CRT = "client.crt证书文件路径";
/**
* 客户端证书key
*/
public final static String SSL_CLIENT_KEY_PKCS8_PEM = "client-key-pkcs8.pem证书文件路径";
/**
* 客户端证书密码
*/
public final static String SSL_CLIENT_PASSWORD = "client_password";
//消息发送的类型
/**
* 尽力而为。消息发送者会想尽办法发送消息，但是遇到意外并不会重试
*/
public final static int QOS_UNRELIABLE = 0;
/**
* 至少一次。消息接收者如果没有知会或者知会本身丢失，消息发送者会再次发送以保证消息接收者至少会收到一次，当然可能造成重复消息。
*/
public final static int QOS_REPEAT = 1;
/**
* 恰好一次。保证这种语义肯待会减少并发或者增加延时，不过丢失或者重复消息是不可接受的时候，级别2是最合适的。
*/
public final static int QOS_JUST = 2;
}
MQTT生产者客户端
/**
* 服务器【应用程序】Mqtt消息推送工具类
*/
public class MqttPushUtil {
public static Logger logger = Logger.getLogger(MqttPushUtil.class);
public static MqttClient mqttClient;
public static MqttConnectOptions mqttConnectOptions = new MqttConnectOptions();
static {
try{
//创建客户端
mqttClient = new MqttClient(MqttConstant.MQTT_IP_PORT, MqttConstant.MQTT_CLIENTID, new MemoryPersistence());
//创建链接参数
mqttConnectOptions = new MqttConnectOptions();
//在客户端断开连接时是否缓存 订阅消息
mqttConnectOptions.setCleanSession(true);
//设置连接的用户名
mqttConnectOptions.setUserName(MqttConstant.MQTT_USERNAME);
//设置连接的密码
mqttConnectOptions.setPassword(MqttConstant.MQTT_PASSWORD.toCharArray());
//开启自动重连
mqttConnectOptions.setAutomaticReconnect(true);
//设置超时时间 单位为秒
mqttConnectOptions.setConnectionTimeout(30);
//设置会话心跳时间 单位为秒 服务器会每隔1.5*20秒的时间向客户端发送个消息判断客户端是否在线，但这个方法并没有重连的机制
mqttConnectOptions.setKeepAliveInterval(20);
//ssl 双向认证相关配置
SSLSocketFactory factory = EmqxSSLFactory.getSSLSocktet(MqttConstant.SSL_CA_CRT, MqttConstant.SSL_CLIENT_CRT,
MqttConstant.SSL_CLIENT_KEY_PKCS8_PEM, MqttConstant.SSL_CLIENT_PASSWORD);
mqttConnectOptions.setSocketFactory(factory);
// MqttPushServerUtil.setClient(mqttClient);
mqttClient.connect(mqttConnectOptions);
}catch (Exception e){
e.printStackTrace();
logger.error("连接MQTT服务器发生异常", e);
try{
mqttClient.disconnect();;
mqttClient.close();
}catch (MqttException el){
e.printStackTrace();
logger.error("连接异常时-----》断开与MQTT服务器连接操作发生异常", el);
}
}
}
public static void receiveSubscription(){
try{
mqttClient.setCallback(new MqttCallback() {
/**
*检测到断开连接
* @param throwable
*/
@Override
public void connectionLost(Throwable throwable) {
//MQTT客户端断线重连
reconnection();
}
/**
* 接收订阅消息处理
* @param topic
* @param mqttMessage
* @throws Exception
*/
@Override
public void messageArrived(String topic, MqttMessage mqttMessage) throws Exception {
System.out.println("topic:"+topic);
System.out.println("Qos:"+mqttMessage.getQos());
System.out.println("message content:"+new String(mqttMessage.getPayload()));
}
/**
* 消息发布结果
* @param iMqttDeliveryToken
*/
@Override
public void deliveryComplete(IMqttDeliveryToken iMqttDeliveryToken) {
logger.info("MQTT消息发布的结果：---------"+ iMqttDeliveryToken.isComplete());
}
});
mqttClient.subscribe(MqttConstant.MQTT_TOPIC, MqttConstant.QOS_JUST);
}catch (Exception e){
e.printStackTrace();
logger.error("MQTT客户端---公租房系统：接收消息时发生异常！", e);
}
}
/**
* MQTT客户端断线重连
*/
public static void reconnection(){
logger.error("与MQTT服务器断开连接，尝试重新连接！");
try {
if(!mqttConnectOptions.isAutomaticReconnect()){
mqttClient.reconnect();
}
}catch (MqttException e){
logger.error("MQTT重新连接发生异常！", e);
}
}
/**
* 发布非可靠的消息【消息服务质量：0】
* @param topic 发布主题
* @param pushMessage 消息内容
*/
public static boolean publishUnreliable(String topic, String pushMessage) {
return publish(MqttConstant.QOS_UNRELIABLE, topic, pushMessage);
}
/**
* 以至少收到一次的模式发送消息【可能重复，消息服务质量：1】
* @param topic 发布主题
* @param pushMessage 消息内容
*/
public static boolean publishLeastOnce(String topic, String pushMessage) {
return publish(MqttConstant.QOS_REPEAT, topic, pushMessage);
}
/**
* 发送可靠的保证 能且只能收到一次的消息【消息服务质量：2】
* @param topic
* @param pushMessage
*/
public static boolean publishReliable(String topic, String pushMessage) {
return publish(MqttConstant.QOS_JUST, topic, pushMessage);
}
/**
* 发布主题和消息队列
* @param qos
* @param topic
* @param pushMessage
* @return
*/
public static boolean publish(int qos, String topic, String pushMessage) {
try {
// 创建消息
MqttMessage message = new MqttMessage(pushMessage.getBytes());
// 设置消息的服务质量
message.setQos(qos);
// 发布消息
mqttClient.publish(topic, message);
} catch (MqttException e) {
logger.error("发布消息时发生异常！",e);
return false;
}
return true;
}
}
EmqxSSL连接工厂类
public class EmqxSSLFactory {
public static javax.net.ssl.SSLSocketFactory getSSLSocktet(String caPath, String crtPath, String keyPath, String password) {
try{
CertificateFactory cAf = CertificateFactory.getInstance("X.509");
FileInputStream caIn = new FileInputStream(caPath);
X509Certificate ca = (X509Certificate) cAf.generateCertificate(caIn);
KeyStore caKs = KeyStore.getInstance("JKS");
caKs.load(null, null);
caKs.setCertificateEntry("ca-certificate", ca);
TrustManagerFactory tmf = TrustManagerFactory.getInstance("PKIX");
tmf.init(caKs);
CertificateFactory cf = CertificateFactory.getInstance("X.509");
FileInputStream crtIn = new FileInputStream(crtPath);
X509Certificate caCert = (X509Certificate) cf.generateCertificate(crtIn);
crtIn.close();
KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
ks.load(null, null);
ks.setCertificateEntry("certificate", caCert);
ks.setKeyEntry("private-key", getPrivateKey(keyPath), password.toCharArray(),
new java.security.cert.Certificate[]{caCert});
KeyManagerFactory kmf = KeyManagerFactory.getInstance("PKIX");
kmf.init(ks, password.toCharArray());
SSLContext context = SSLContext.getInstance("TLSv1");
context.init(kmf.getKeyManagers(), tmf.getTrustManagers(), new SecureRandom());
return context.getSocketFactory();
}catch (Exception e){
e.printStackTrace();
}
return null;
}
public static PrivateKey getPrivateKey(String path) throws Exception {
org.apache.commons.codec.binary.Base64 base64 = new Base64();
byte[] buffer = base64.decode(getPem(path));
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
}
private static String getPem(String path) throws Exception {
FileInputStream fin = new FileInputStream(path);
BufferedReader br = new BufferedReader(new InputStreamReader(fin));
String readLine = null;
StringBuilder sb = new StringBuilder();
while ((readLine = br.readLine()) != null) {
if (readLine.charAt(0) == '-') {
continue;
} else {
sb.append(readLine);
sb.append('\r');
}
}
fin.close();
return sb.toString();
}
}
测试类
public class MqttPushClientUtil {
public static void main(String[] args) throws MqttException {
String HOST = MqttConstant.MQTT_IP_PORT;
String[] TOPIC = {"dev/mac/+", "dev/village/+"};
int[] qos = new int[]{2, 2};
String clientid = "subClient";
String userName = "username";
String passWord = "password";
try {
// host为主机名，test为clientid即连接MQTT的客户端ID，一般以客户端唯一标识符表示，MemoryPersistence设置clientid的保存形式，默认为以内存保存
MqttClient client = new MqttClient(HOST, clientid, new MemoryPersistence());
// MQTT的连接设置
MqttConnectOptions options = new MqttConnectOptions();
// 设置是否清空session,这里如果设置为false表示服务器会保留客户端的连接记录，这里设置为true表示每次连接到服务器都以新的身份连接
SSLSocketFactory factory = EmqxSSLFactory.getSSLSocktet(MqttConstant.SSL_CA_CRT, MqttConstant.SSL_CLIENT_CRT,
MqttConstant.SSL_CLIENT_KEY_PKCS8_PEM, MqttConstant.SSL_CLIENT_PASSWORD);
options.setSocketFactory(factory);
options.setCleanSession(true);
// 设置连接的用户名
options.setUserName(userName);
// 设置连接的密码
options.setPassword(passWord.toCharArray());
// 设置超时时间 单位为秒
options.setConnectionTimeout(10);
// 设置会话心跳时间 单位为秒 服务器会每隔1.5*20秒的时间向客户端发送个消息判断客户端是否在线，但这个方法并没有重连的机制
options.setKeepAliveInterval(20);
// 设置回调函数
client.setCallback(new MqttCallback() {
@Override
public void connectionLost(Throwable cause) {
System.out.println("connectionLost");
}
@Override
public void messageArrived(String topic, MqttMessage message) throws Exception {
System.out.println("topic:"+topic);
System.out.println("Qos:"+message.getQos());
System.out.println("message content:"+new String(message.getPayload()));
}
@Override
public void deliveryComplete(IMqttDeliveryToken token) {
System.out.println("deliveryComplete---------"+ token.isComplete());
}
});
client.connect(options);
//订阅消息
client.subscribe(TOPIC, qos);
} catch (Exception e) {
e.printStackTrace();
}
Map<String, Object> map = new HashMap<>();
map.put("index", 1);
map.put("text", "设备信息");
MqqtPushServiceUtil.pushDeviceMsg("00:00:a4:01:01:01", "12", map);
try{
Thread.sleep(5000);
}catch (Exception e){
e.printStackTrace();
}
map.put("index", 2);
map.put("text", "小区信息");
MqqtPushServiceUtil.pushVillageMsg(123, "12", map);
}
}
参考
证书格式转换: https://vimsky.com/article/3608.html
其他证书生成方式：
emqtt安全连接ssl配置 自签证书 单向认证连接 加密 ssl/tls，mosquitto客户端ssl单向认证连接测试
emqx使用自制CA证书登录配置（双向认证）
EMQ X 服务器 SSL/TLS 安全连接配置指南
MQTT研究之EMQ：【SSL双向验证】
MQTT研究之EMQ：【JAVA代码构建X509证书】
其他编码实现
MQTT Java客户端Eclipse paho实现数据的发送和接收
emqtt 试用（八）ssl认证 - 代码验证
MQTT.fx客户端安装与使用
MQTT.fx的安装和使用
EMQX权限验证
emqx服务器的权限验证（四）