使用paho.mqtt.embedded-c和openssl实现MQTT的单向认证功能
1、背景
由于项目有需求在一个现有的产品上增加MQTT通信的功能，且出于安全考虑，MQTT要走TLS，采用单向认证的方式。
2、方案选择
由于是在现有的产品上新增功能，那么为了减少总的成本，故选择只动应用软件的来实现需求。
MQTT的功能直接选择PahoMqtt这个第三方库来实现，因为以前用过，比较熟悉。由于只想动应用软件，那么只能选择他的embedded-c分支，这样才可以直接集成代码，而不需要编译成so放到固件里，同时也减少程序体积的增加。
embedded-c分支不支持TLS，那么就要想办法自己给embedded-c实现TLS的功能，经过考虑，现有的产品里有openssl库，故使用openssl来给embedded-c添加TLS的支持。
最终方案为：paho.mqtt.embedded-c实现MQTT的连接、断开和收\发，使用openssl来给embedded-c添加TLS的支持。
3、实现代码
step1：先去github把源码下载下来
GitHub - eclipse/paho.mqtt.embedded-c: Paho MQTT C client library for embedded systems. Paho is an Eclipse IoT project (https://iot.eclipse.org/)
step2：把对应的代码文件集成到项目里。
这里只需要MQTTPacket/src目录下的所有代码、MQTTClient-C/src/linux目录下的所有代码、MQTTClient-C/src目录下的MQTTClient.h和MQTTClient.c这两个文件就行了。具体内容如下图：
到这一步，paho.mqtt.embedded-c基本的就集成完了，对应的调用例子可以参考MQTTClient/samples/linux/main.cpp和MQTTClient-C/samples/linux/stdoutsub.c这两个文件，这里就不多赘述了。
step3：使用openssl给embedded-c增加TLS单向认证的支持
1、修改MQTTLinux.h文件
主要是修改点有两点：1、struct Network的内容，增加ssl的支持；2、新增两条NetworkConnect函数，一条用来走TCP，一条用来走TLS。（这里我选择保留最原始的NetworkConnect函数，方便以后debug的时候对比用。）
/*******************************************************************************
* Copyright (c) 2014 IBM Corp.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v1.0 which accompany this distribution.
*
* The Eclipse Public License is available at
* http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Allan Stockdill-Mander - initial API and implementation and/or initial documentation
*******************************************************************************/
#if !defined(__MQTT_LINUX_)
#define __MQTT_LINUX_
#if defined(WIN32_DLL) || defined(WIN64_DLL)
#define DLLImport __declspec(dllimport)
#define DLLExport __declspec(dllexport)
#elif defined(LINUX_SO)
#define DLLImport extern
#define DLLExport __attribute__ ((visibility ("default")))
#else
#define DLLImport
#define DLLExport
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
typedef struct Timer
{
struct timeval end_time;
} Timer;
void TimerInit(Timer*);
char TimerIsExpired(Timer*);
void TimerCountdownMS(Timer*, unsigned int);
void TimerCountdown(Timer*, unsigned int);
int TimerLeftMS(Timer*);
typedef struct Network
{
/* socket的描述符 */
int my_socket;
/* 读取MQTT消息的函数 */
int (*mqttread) (struct Network*, unsigned char*, int, int);
/* 发送MQTT消息的函数 */
int (*mqttwrite) (struct Network*, unsigned char*, int, int);
/* 使用SSL时的描述符 */
SSL *ssl;
/* 是否使用SSL 0：否 1：是 */
int useSSL;
} Network;
int linux_read(Network*, unsigned char*, int, int);
int linux_write(Network*, unsigned char*, int, int);
/* 初始化Network这个结构体 */
DLLExport void NetworkInit(Network*);
/* 连接Network（普通socket） */
DLLExport int NetworkConnect(Network*, char*, int);
/* 连接Network（带SSL的socket） */
DLLExport int NetworkConnectBySSL(Network*, const char*, const char*, const char*);
/* 连接Network（不带SSL的socket） */
DLLExport int NetworkConnectNotSSL(Network*, const char*, const char*);
/* 断开Network的连接 */
DLLExport void NetworkDisconnect(Network*);
/* 打印证书的内容 */
DLLExport void ShowCerts(SSL *);
#endif
2、修改MQTTLinux.c文件
这里就把定义的那些给实现出来。
用Network这个结构体存放是否需要走ssl的信息，同时把SSL用的描述符也放在里面，方便后续传递。
调用不同的NetworkConnect的时候，在Network里面存储不同的信息
/*******************************************************************************
* Copyright (c) 2014, 2017 IBM Corp.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v1.0 which accompany this distribution.
*
* The Eclipse Public License is available at
* http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Allan Stockdill-Mander - initial API and implementation and/or initial documentation
* Ian Craggs - return codes from linux_read
*******************************************************************************/
#include "MQTTLinux.h"
void TimerInit(Timer* timer)
{
timer->end_time = (struct timeval){0, 0};
}
char TimerIsExpired(Timer* timer)
{
struct timeval now, res;
gettimeofday(&now, NULL);
timersub(&timer->end_time, &now, &res);
return res.tv_sec < 0 || (res.tv_sec == 0 && res.tv_usec <= 0);
}
void TimerCountdownMS(Timer* timer, unsigned int timeout)
{
struct timeval now;
gettimeofday(&now, NULL);
struct timeval interval = {timeout / 1000, (timeout % 1000) * 1000};
timeradd(&now, &interval, &timer->end_time);
}
void TimerCountdown(Timer* timer, unsigned int timeout)
{
struct timeval now;
gettimeofday(&now, NULL);
struct timeval interval = {timeout, 0};
timeradd(&now, &interval, &timer->end_time);
}
int TimerLeftMS(Timer* timer)
{
struct timeval now, res;
gettimeofday(&now, NULL);
timersub(&timer->end_time, &now, &res);
//printf("left %d ms\n", (res.tv_sec < 0) ? 0 : res.tv_sec * 1000 + res.tv_usec / 1000);
return (res.tv_sec < 0) ? 0 : res.tv_sec * 1000 + res.tv_usec / 1000;
}
/**
* 从MQTT读数据
*
* @param n : Network对象的指针
* @param buffer ： 存放数据的指针
* @param len ： 指针长度
* @param timeout_ms : 超时时间
* @return 读出的长度
*/
int linux_read(Network* n, unsigned char* buffer, int len, int timeout_ms)
{
struct timeval interval = {timeout_ms / 1000, (timeout_ms % 1000) * 1000};
if (interval.tv_sec < 0 || (interval.tv_sec == 0 && interval.tv_usec <= 0))
{
interval.tv_sec = 0;
interval.tv_usec = 100;
}
setsockopt(n->my_socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&interval, sizeof(struct timeval));
setsockopt(n->ssl, SOL_SOCKET, SO_RCVTIMEO, (char *)&interval, sizeof(struct timeval));
int bytes = 0;
while (bytes < len)
{
int rc = -1;
/* 是不是使用SSL决定了从哪个描述符读数据 */
if(n->useSSL==1){
rc = SSL_read(n->ssl, buffer+bytes, (len - bytes));
}else{
rc = read(n->my_socket, buffer+bytes, (len - bytes));
}
if (rc == -1)
{
if (errno != EAGAIN && errno != EWOULDBLOCK)
bytes = -1;
break;
}
else if (rc == 0)
{
bytes = 0;
break;
}
else
bytes += rc;
}
return bytes;
}
/**
* 写数据到mqtt
*
* @param n : Network对象的指针
* @param buffer ： 存放数据的指针
* @param len ： 数据长度
* @param timeout_ms : 超时时间
* @return 写出的长度
*/
int linux_write(Network* n, unsigned char* buffer, int len, int timeout_ms)
{
struct timeval tv;
tv.tv_sec = 0; /* 30 Secs Timeout */
tv.tv_usec = timeout_ms * 1000; // Not init'ing this can cause strange errors
setsockopt(n->my_socket, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv,sizeof(struct timeval));
int rc = -1;
/* 是不是使用SSL决定了从哪个描述符写数据 */
if(n->useSSL == 1){
rc = SSL_write(n->ssl, buffer, len);
}else{
rc = write(n->my_socket, buffer, len);
}
return rc;
}
/**
* 初始化Network对象
*
* @param n : Network对象的指针
*/
void NetworkInit(Network* n)
{
n->my_socket = 0;
n->mqttread = linux_read;
n->mqttwrite = linux_write;
n->useSSL = 0;
}
/**
* 原版的不带SSL的连接函数（这里改动了一点就是给useSSL赋值了）
*
* @param n : Network对象的指针
* @param addr ： MQTT服务器的IP地址
* @param port ： MQTT服务器的IP地址
* @return 0：成功 其他：失败
*/
int NetworkConnect(Network* n, char* addr, int port)
{
int type = SOCK_STREAM;
struct sockaddr_in address;
int rc = -1;
sa_family_t family = AF_INET;
struct addrinfo *result = NULL;
struct addrinfo hints = {0, AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, 0, NULL, NULL, NULL};
if ((rc = getaddrinfo(addr, NULL, &hints, &result)) == 0)
{
struct addrinfo* res = result;
/* prefer ip4 addresses */
while (res)
{
if (res->ai_family == AF_INET)
{
result = res;
break;
}
res = res->ai_next;
}
if (result->ai_family == AF_INET)
{
address.sin_port = htons(port);
address.sin_family = family = AF_INET;
address.sin_addr = ((struct sockaddr_in*)(result->ai_addr))->sin_addr;
}
else
rc = -1;
freeaddrinfo(result);
}
if (rc == 0)
{
n->my_socket = socket(family, type, 0);
n->useSSL = 0;
if (n->my_socket != -1){
rc = connect(n->my_socket, (struct sockaddr*)&address, sizeof(address));
}
}
return rc;
}
/**
* 打印证书内容
*
* @param ssl ： SSL的描述符
*/
void ShowCerts(SSL * ssl)
{
X509 *cert;
char *line;
cert = SSL_get_peer_certificate(ssl);
if (cert != NULL) {
printf("数字证书信息:\n");
line = X509_NAME_oneline(X509_get_subject_name(cert), 0, 0);
printf("证书: %s\n", line);
free(line);
line = X509_NAME_oneline(X509_get_issuer_name(cert), 0, 0);
printf("颁发者: %s\n", line);
free(line);
X509_free(cert);
} else {
printf("无证书信息！\n");
}
}
/**
* 连接Network（带SSL的socket）
*
* @param n : Network对象的指针
* @param addr ： MQTT服务器的IP地址
* @param port ： MQTT服务器的IP地址
* @param crtFilePath ： 证书路径
* @return 0：成功 其他：失败
*/
int NetworkConnectBySSL(Network* n, const char* addr, const char* port, const char* crtFilePath)
{
SSL_CTX* ssl_context;
SSL *ssl;
/*SSL初始化*/
SSL_library_init();
OpenSSL_add_all_algorithms();
SSL_load_error_strings();
/* 创建SSL的上下文 */
ssl_context = SSL_CTX_new(TLSv1_2_client_method());
/*设置只验证服务器的证书*/
SSL_CTX_set_verify(ssl_context, SSL_VERIFY_PEER, NULL);
/* 设置用来进行校验的证书 */
if (SSL_CTX_use_certificate_file(ssl_context, crtFilePath, SSL_FILETYPE_PEM) != 1) {
SSL_CTX_free(ssl_context);
printf("Failed to load client certificate from %s", crtFilePath);
}
SSL_CTX_set_default_verify_paths(ssl_context);
/* 创建Socket并连接到服务器 */
int socketFd = -1;
if ((socketFd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("create socket failed! %s", strerror(errno));
return -1;
}
/* 解析链接地址和消息 */
struct addrinfo hints = {};
struct addrinfo* serverInfo;
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
int result = getaddrinfo(addr, port, &hints, &serverInfo);
if (result != 0) {
printf("Failed to get addr info= %s addr=%s port=%s", gai_strerror(result),addr,port);
return -1;
}
/* 连接服务端socket */
if (connect(socketFd, serverInfo->ai_addr, serverInfo->ai_addrlen) != 0) {
printf("Connect socket failed! %s", strerror(errno));
return -1;
}
/* 让socket走SSL */
ssl = SSL_new(ssl_context);
SSL_set_fd(ssl, socketFd);
if (SSL_connect(ssl) == -1) {
ERR_print_errors_fp(stderr);
return -1;
} else {
printf("Connected with %s encryption\n", SSL_get_cipher(ssl));
/* 打印一下证书的内容 */
ShowCerts(ssl);
/* 检查一下证书 */
/* 把对应的描述符什么的存起来 */
n->my_socket = socketFd;
n->ssl = ssl;
n->useSSL = 1;
}
return 0;
}
/**
* 连接Network（不带SSL的socket）
*
* @param n : Network对象的指针
* @param addr ： MQTT服务器的IP地址
* @param port ： MQTT服务器的IP地址
* @return 0：成功 其他：失败
*/
int NetworkConnectNotSSL(Network* n, const char* addr, const char* port)
{
n->useSSL = 0;
/* 创建Socket并连接到服务器 */
int socketFd = -1;
if ((socketFd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("create socket failed! %s", strerror(errno));
return -1;
}
/* 解析链接地址和消息 */
struct addrinfo hints = {};
struct addrinfo* serverInfo;
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
int result = getaddrinfo(addr, port, &hints, &serverInfo);
if (result != 0) {
printf("Failed to get addr info= %s addr=%s port=%s", gai_strerror(result),addr,port);
return -1;
}
/* 连接服务端socket */
if (connect(socketFd, serverInfo->ai_addr, serverInfo->ai_addrlen) != 0) {
printf("Connect socket failed! %s", strerror(errno));
return -1;
}else{
n->my_socket = socketFd;
return 0;
}
}
/**
* 断开连接
*
* @param n : Network对象的指针
*/
void NetworkDisconnect(Network* n)
{
close(n->my_socket);
if(n->useSSL == 1){
SSL_shutdown(n->ssl);
}
}
到这里我们就已经给embedded-c添加完TLS的支持，并使用的是单向校验
step4：发起MQTT连接连接
这里就直接贴调用代码好了
/**
* 连接MQTT
*
* @return 0：成功 其他：失败
*/
int connectMqtt() {
/* MQTT的发送缓冲区和接收缓冲区 */
uint8_t *sendbuf;
uint8_t *recvbuf;
/* MQTT的发送缓冲区和接收缓冲区的大小 */
const int MAX_SENDBUF_SIZE = 1024 * 30;
const int MAX_RECVBUF_SIZE = 1024 * 30;
/* MQTT的收发超时时间，单位ms */
const int MAX_MQTT_TIMEOUT_TIME = 1000;
/* 定义实现网络操作的工具 */
Network mqttNetworkUtil;
/* MQTT客户端操作类 */
MQTTClient mqttClient;
int rc = -1;
/* 初始化一下网络操作工具 */
NetworkInit(&mqttNetworkUtil);
/* 使用SSL的方式连接MQTT服务器的Socket */
NetworkConnectBySSL(&mqttNetworkUtil, G3_Configuration::getInstance().getNdsMqttConnectParams().host.c_str(),
std::to_string(G3_Configuration::getInstance().getNdsMqttConnectParams().port).c_str(), G3_Configuration::getInstance().getNdsMqttConnectParams().crtFilePath.c_str());
/* 初始化MQTT客户端 */
MQTTClientInit(&mqttClient, &mqttNetworkUtil, MAX_MQTT_TIMEOUT_TIME, sendbuf, MAX_SENDBUF_SIZE, recvbuf,
MAX_RECVBUF_SIZE);
/* 设置一下接收MQTT消息的回调函数，当MQTT收到消息后会自动回调 */
mqttClient.defaultMessageHandler = defaultMessageHandler;
/* 设置一下MQTT的一些连接参数 */
MQTTPacket_connectData data = MQTTPacket_connectData_initializer;
data.willFlag = 1; // 启用遗嘱
data.will.topicName.cstring = G3_Configuration::getInstance().getNdsMqttConnectParams().willTopic.c_str(); // 设置遗嘱的topic名
data.will.qos = QOS2; // 遗嘱的QOS
data.will.message.cstring = G3_Configuration::getInstance().getNdsMqttConnectParams().clientId.c_str(); // 遗嘱的内容（这里使用clientId作为遗嘱的内容）
data.MQTTVersion = 3;
data.clientID.cstring = G3_Configuration::getInstance().getNdsMqttConnectParams().clientId.c_str();
data.username.cstring = G3_Configuration::getInstance().getNdsMqttConnectParams().userName.c_str();
data.password.cstring = G3_Configuration::getInstance().getNdsMqttConnectParams().password.c_str();
data.keepAliveInterval = 60;
data.cleansession = 1;
printf("Connecting to %s %d\n", G3_Configuration::getInstance().getNdsMqttConnectParams().host.c_str(),
G3_Configuration::getInstance().getNdsMqttConnectParams().port);
/* 发起MQTT的连接消息，前面只是socket，这个里发送MQTT协议中的连接消息，这里成功了才算MQTT连接成功 */
rc = MQTTConnect(&mqttClient, &data);
printf("MQTTConnect %d, Connect aliyun IoT Cloud Success!\n", rc);
/* 如果连接成功，就订阅一下用来接收消息的订阅字 */
if (rc == 0) {
printf("Subscribing to %s\n", G3_Configuration::getInstance().getNdsMqttConnectParams().subTopic.c_str());
rc = MQTTSubscribe(&mqttClient, G3_Configuration::getInstance().getNdsMqttConnectParams().subTopic.c_str(),
QOS2, defaultMessageHandler);
printf("MQTTSubscribe %d\n", rc);
}
return rc;
}
/**
* 接收到MQTT消息的时候的回调函数
*
* @param md ： MQTT消息的封装
*/
void messageArrived(MessageData *md) {
MQTTMessage *message = md->message;
callback->onGetDataFromMQTT(curMqttClientType, md->topicName->lenstring.data, md->topicName->lenstring.len,
(char *) message->payload, (int) message->payloadlen);
// printf("messageArrived %.*s\t", md->topicName->lenstring.len, md->topicName->lenstring.data);
// printf("messageArrived %.*s\n", (int) message->payloadlen, (char *) message->payload);
}
/**
* 发布消息
*
* @param mqttClient ： MQTT客户端的对象
* @param msg ： 封装好的消息
*
* @return 0：成功 其他:失败
*/
int publishMessage(MQTTClient &mqttClient,MQTTMessage &msg) {
return MQTTPublish(&mqttClient, G3_Configuration::getInstance().getNdsMqttConnectParams().pubTopic.c_str(), &msg);
}到这里连接也做完了，直接调用connectMqtt()就可以连接到MQTT了，需要发送调用publishMessage（）就可以发送了。如果MQTT那边有订阅的消息过来，那么会自动回messageArrived（）。这里涉及到一个结构体MQTTMessage，这里简单放下它怎么封装的
MQTTMessage msg = {
QOS2,//服务质量等级
0, //消息是否被保留。如果设置为1，则该消息将被代理服务器保留，这样任何新订阅该主题的客户端都可以立即接收到它。为0的话就算只有现在已经订阅了的能收到
0, //是否重复的消息。当设置为1时，它表示这是一个重复的消息。为0则为新消息
0, //消息ID，理论上每条都应该唯一，这里直接0好了
strData.c_str(), //负载数据，就是这条消息实际的内容
strData.size(), //负载数据的长度
};4、其他
1、如果想使用非TLS的MQTT连接，直接把connectMqtt()里面的NetworkConnectBySSL()改成NetworkConnectNotSSL()就好了；
2、如果想使用TLS但是不校验任何证书，那么就修改MQTTLinux.c里面的NetworkConnectBySSL()中SSL_CTX_set_verify（）的第二个参数就好了，把SSL_VERIFY_PEER改成SSL_VERIFY_NONE。这样就即走TLS，但是又不验证服务器的证书。
3、如果想使用双向认证，作为客户端我们这边什么都不用变，因为我们已经开启了认证服务器的证书，服务器那边需要开启认证客户端的证书就行了。
4、connectMqtt()里面填写的clientId和username和password也很重要，因为MQTT服务器可以开启用户认证模式，这样lientId和username和password有一个错误的话都会导致无法连接到服务器。