mirror of
https://github.com/pine64/bl_iot_sdk.git
synced 2024-09-04 14:09:18 +00:00
405 lines
16 KiB
C
405 lines
16 KiB
C
/*
|
|
* Copyright 2010-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License").
|
|
* You may not use this file except in compliance with the License.
|
|
* A copy of the License is located at
|
|
*
|
|
* http://aws.amazon.com/apache2.0
|
|
*
|
|
* or in the "license" file accompanying this file. This file 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.
|
|
*/
|
|
#include <sys/param.h>
|
|
#include <stdbool.h>
|
|
#include <string.h>
|
|
#include <timer_platform.h>
|
|
#include <network_interface.h>
|
|
|
|
#include "aws_iot_config.h"
|
|
#include "aws_iot_error.h"
|
|
#include "network_interface.h"
|
|
#include "network_platform.h"
|
|
|
|
const char *TAG = "aws_iot";
|
|
|
|
#define BFL_LOGD(TAG, format, ...) printf("DEBUG " format "\r\n", ##__VA_ARGS__)
|
|
#define BFL_LOGE(TAG, format, ...) printf("ERROR " format "\r\n", ##__VA_ARGS__)
|
|
#define BFL_LOGW(TAG, format, ...) printf("WARNN " format "\r\n", ##__VA_ARGS__)
|
|
|
|
/*
|
|
* This is a function to do further verification if needed on the cert received.
|
|
*/
|
|
static int _iot_tls_verify_cert(void *data, mbedtls_x509_crt *crt, int depth, uint32_t *flags)
|
|
{
|
|
char buf[256];
|
|
((void) data);
|
|
|
|
BFL_LOGD(TAG, "Verify requested for (Depth %d):", depth);
|
|
mbedtls_x509_crt_info(buf, sizeof(buf) - 1, "", crt);
|
|
BFL_LOGD(TAG, "%s", buf);
|
|
|
|
if((*flags) == 0) {
|
|
BFL_LOGD(TAG, " This certificate has no flags");
|
|
} else {
|
|
BFL_LOGD(TAG, "Verify result:%s", buf);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void _iot_tls_set_connect_params(Network *pNetwork, const char *pRootCALocation, const char *pDeviceCertLocation,
|
|
const char *pDevicePrivateKeyLocation, const char *pDestinationURL,
|
|
uint16_t destinationPort, uint32_t timeout_ms, bool ServerVerificationFlag)
|
|
{
|
|
pNetwork->tlsConnectParams.DestinationPort = destinationPort;
|
|
pNetwork->tlsConnectParams.pDestinationURL = pDestinationURL;
|
|
pNetwork->tlsConnectParams.pDeviceCertLocation = pDeviceCertLocation;
|
|
pNetwork->tlsConnectParams.pDevicePrivateKeyLocation = pDevicePrivateKeyLocation;
|
|
pNetwork->tlsConnectParams.pRootCALocation = pRootCALocation;
|
|
pNetwork->tlsConnectParams.timeout_ms = timeout_ms;
|
|
pNetwork->tlsConnectParams.ServerVerificationFlag = ServerVerificationFlag;
|
|
}
|
|
|
|
IoT_Error_t iot_tls_init(Network *pNetwork, const char *pRootCALocation, const char *pDeviceCertLocation,
|
|
const char *pDevicePrivateKeyLocation, const char *pDestinationURL,
|
|
uint16_t destinationPort, uint32_t timeout_ms, bool ServerVerificationFlag)
|
|
{
|
|
_iot_tls_set_connect_params(pNetwork, pRootCALocation,
|
|
pDeviceCertLocation, pDevicePrivateKeyLocation,
|
|
pDestinationURL, destinationPort,
|
|
timeout_ms, ServerVerificationFlag
|
|
);
|
|
pNetwork->connect = iot_tls_connect;
|
|
pNetwork->read = iot_tls_read;
|
|
pNetwork->write = iot_tls_write;
|
|
pNetwork->disconnect = iot_tls_disconnect;
|
|
pNetwork->isConnected = iot_tls_is_connected;
|
|
pNetwork->destroy = iot_tls_destroy;
|
|
pNetwork->tlsDataParams.flags = 0;
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
IoT_Error_t iot_tls_is_connected(Network *pNetwork)
|
|
{
|
|
/* Use this to add implementation which can check for physical layer disconnect */
|
|
return NETWORK_PHYSICAL_LAYER_CONNECTED;
|
|
}
|
|
|
|
#if 0
|
|
static void aws_debug( void *ctx, int level, const char *file, int line, const char *str )
|
|
{
|
|
printf("[AWS] %s:%04d: %s\r", file, line, str);
|
|
}
|
|
#endif
|
|
|
|
IoT_Error_t iot_tls_connect(Network *pNetwork, TLSConnectParams *params)
|
|
{
|
|
int ret = SUCCESS;
|
|
TLSDataParams *tlsDataParams = NULL;
|
|
char portBuffer[6];
|
|
char info_buf[256];
|
|
|
|
if (NULL == pNetwork) {
|
|
return NULL_VALUE_ERROR;
|
|
}
|
|
|
|
if (NULL != params) {
|
|
_iot_tls_set_connect_params(pNetwork, params->pRootCALocation, params->pDeviceCertLocation,
|
|
params->pDevicePrivateKeyLocation,
|
|
params->pDestinationURL,
|
|
params->DestinationPort,
|
|
params->timeout_ms,
|
|
params->ServerVerificationFlag
|
|
);
|
|
}
|
|
|
|
tlsDataParams = &(pNetwork->tlsDataParams);
|
|
mbedtls_net_init(&(tlsDataParams->server_fd));
|
|
mbedtls_ssl_init(&(tlsDataParams->ssl));
|
|
mbedtls_ssl_config_init(&(tlsDataParams->conf));
|
|
|
|
mbedtls_ctr_drbg_init(&(tlsDataParams->ctr_drbg));
|
|
mbedtls_x509_crt_init(&(tlsDataParams->cacert));
|
|
mbedtls_x509_crt_init(&(tlsDataParams->clicert));
|
|
mbedtls_pk_init(&(tlsDataParams->pkey));
|
|
|
|
BFL_LOGD(TAG, "Seeding the random number generator...");
|
|
mbedtls_entropy_init(&(tlsDataParams->entropy));
|
|
if ((ret = mbedtls_ctr_drbg_seed(&(tlsDataParams->ctr_drbg), mbedtls_entropy_func, &(tlsDataParams->entropy), (const unsigned char *) TAG, strlen(TAG))) != 0) {
|
|
BFL_LOGE(TAG, "failed! mbedtls_ctr_drbg_seed returned -0x%x", -ret);
|
|
return NETWORK_MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED;
|
|
}
|
|
|
|
/* Load root CA...
|
|
Certs/keys can be paths or they can be raw data. These use a
|
|
very basic heuristic: if the cert starts with '/' then it's a
|
|
path, if it's longer than this then it's raw cert data (PEM or DER,
|
|
neither of which can start with a slash.
|
|
*/
|
|
if (pNetwork->tlsConnectParams.pRootCALocation[0] == '/') {
|
|
BFL_LOGD(TAG, "Loading CA root certificate from file ...");
|
|
ret = mbedtls_x509_crt_parse_file(&(tlsDataParams->cacert), pNetwork->tlsConnectParams.pRootCALocation);
|
|
} else {
|
|
BFL_LOGD(TAG, "Loading embedded CA root certificate ...");
|
|
ret = mbedtls_x509_crt_parse(&(tlsDataParams->cacert), (const unsigned char *)pNetwork->tlsConnectParams.pRootCALocation, strlen(pNetwork->tlsConnectParams.pRootCALocation)+1);
|
|
}
|
|
|
|
if (ret < 0) {
|
|
BFL_LOGE(TAG, "failed! mbedtls_x509_crt_parse returned -0x%x while parsing root cert", -ret);
|
|
return NETWORK_X509_ROOT_CRT_PARSE_ERROR;
|
|
}
|
|
BFL_LOGD(TAG, "ok (%d skipped)", ret);
|
|
|
|
/* Load client certificate... */
|
|
if (pNetwork->tlsConnectParams.pDeviceCertLocation[0] == '/') {
|
|
BFL_LOGD(TAG, "Loading client cert from file...");
|
|
ret = mbedtls_x509_crt_parse_file(&(tlsDataParams->clicert), pNetwork->tlsConnectParams.pDeviceCertLocation);
|
|
} else {
|
|
BFL_LOGD(TAG, "Loading embedded client certificate...");
|
|
ret = mbedtls_x509_crt_parse(&(tlsDataParams->clicert), (const unsigned char *)pNetwork->tlsConnectParams.pDeviceCertLocation, strlen(pNetwork->tlsConnectParams.pDeviceCertLocation)+1);
|
|
}
|
|
if(ret != 0) {
|
|
BFL_LOGE(TAG, "failed! mbedtls_x509_crt_parse returned -0x%x while parsing device cert", -ret);
|
|
return NETWORK_X509_DEVICE_CRT_PARSE_ERROR;
|
|
}
|
|
|
|
/* Parse client private key... */
|
|
if (pNetwork->tlsConnectParams.pDevicePrivateKeyLocation[0] == '/') {
|
|
BFL_LOGD(TAG, "Loading client private key from file...");
|
|
ret = mbedtls_pk_parse_keyfile(&(tlsDataParams->pkey), pNetwork->tlsConnectParams.pDevicePrivateKeyLocation, "");
|
|
} else {
|
|
BFL_LOGD(TAG, "Loading embedded client private key...");
|
|
ret = mbedtls_pk_parse_key(&(tlsDataParams->pkey),
|
|
(const unsigned char *)pNetwork->tlsConnectParams.pDevicePrivateKeyLocation,
|
|
strlen(pNetwork->tlsConnectParams.pDevicePrivateKeyLocation)+1,
|
|
(const unsigned char *)"", 0);
|
|
}
|
|
if (ret != 0) {
|
|
BFL_LOGE(TAG, "failed! mbedtls_pk_parse_key returned -0x%x while parsing private key", -ret);
|
|
return NETWORK_PK_PRIVATE_KEY_PARSE_ERROR;
|
|
}
|
|
|
|
/* Done parsing certs */
|
|
BFL_LOGD(TAG, "ok");
|
|
snprintf(portBuffer, 6, "%d", pNetwork->tlsConnectParams.DestinationPort);
|
|
BFL_LOGD(TAG, "Connecting to %s/%s...", pNetwork->tlsConnectParams.pDestinationURL, portBuffer);
|
|
if ((ret = mbedtls_net_connect(&(tlsDataParams->server_fd), pNetwork->tlsConnectParams.pDestinationURL, portBuffer, MBEDTLS_NET_PROTO_TCP)) != 0) {
|
|
BFL_LOGE(TAG, "failed! mbedtls_net_connect returned -0x%x", -ret);
|
|
switch (ret) {
|
|
case MBEDTLS_ERR_NET_SOCKET_FAILED:
|
|
return NETWORK_ERR_NET_SOCKET_FAILED;
|
|
case MBEDTLS_ERR_NET_UNKNOWN_HOST:
|
|
return NETWORK_ERR_NET_UNKNOWN_HOST;
|
|
case MBEDTLS_ERR_NET_CONNECT_FAILED:
|
|
default:
|
|
return NETWORK_ERR_NET_CONNECT_FAILED;
|
|
};
|
|
}
|
|
|
|
ret = mbedtls_net_set_block(&(tlsDataParams->server_fd));
|
|
if (ret != 0) {
|
|
BFL_LOGE(TAG, "failed! net_set_(non)block() returned -0x%x", -ret);
|
|
return SSL_CONNECTION_ERROR;
|
|
}
|
|
BFL_LOGD(TAG, "ok");
|
|
BFL_LOGD(TAG, "Setting up the SSL/TLS structure...");
|
|
if((ret = mbedtls_ssl_config_defaults(&(tlsDataParams->conf), MBEDTLS_SSL_IS_CLIENT, MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT)) != 0) {
|
|
BFL_LOGE(TAG, "failed! mbedtls_ssl_config_defaults returned -0x%x", -ret);
|
|
return SSL_CONNECTION_ERROR;
|
|
}
|
|
|
|
mbedtls_ssl_conf_verify(&(tlsDataParams->conf), _iot_tls_verify_cert, NULL);
|
|
|
|
if (pNetwork->tlsConnectParams.ServerVerificationFlag == true) {
|
|
mbedtls_ssl_conf_authmode(&(tlsDataParams->conf), MBEDTLS_SSL_VERIFY_REQUIRED);
|
|
} else {
|
|
mbedtls_ssl_conf_authmode(&(tlsDataParams->conf), MBEDTLS_SSL_VERIFY_OPTIONAL);
|
|
}
|
|
mbedtls_ssl_conf_rng(&(tlsDataParams->conf), mbedtls_ctr_drbg_random, &(tlsDataParams->ctr_drbg));
|
|
|
|
mbedtls_ssl_conf_ca_chain(&(tlsDataParams->conf), &(tlsDataParams->cacert), NULL);
|
|
ret = mbedtls_ssl_conf_own_cert(&(tlsDataParams->conf), &(tlsDataParams->clicert), &(tlsDataParams->pkey));
|
|
if (ret != 0) {
|
|
BFL_LOGE(TAG, "failed! mbedtls_ssl_conf_own_cert returned %d", ret);
|
|
return SSL_CONNECTION_ERROR;
|
|
}
|
|
|
|
mbedtls_ssl_conf_read_timeout(&(tlsDataParams->conf), pNetwork->tlsConnectParams.timeout_ms);
|
|
/* Use the AWS IoT ALPN extension for MQTT, if port 443 is requested */
|
|
if (pNetwork->tlsConnectParams.DestinationPort == 443) {
|
|
const char *alpnProtocols[] = { "x-amzn-mqtt-ca", NULL };
|
|
if ((ret = mbedtls_ssl_conf_alpn_protocols(&(tlsDataParams->conf), alpnProtocols)) != 0) {
|
|
BFL_LOGE(TAG, "failed! mbedtls_ssl_conf_alpn_protocols returned -0x%x", -ret);
|
|
return SSL_CONNECTION_ERROR;
|
|
}
|
|
}
|
|
|
|
//mbedtls_ssl_conf_dbg(&(tlsDataParams->conf), aws_debug, stdout );
|
|
//mbedtls_debug_set_threshold(20);
|
|
if ((ret = mbedtls_ssl_setup(&(tlsDataParams->ssl), &(tlsDataParams->conf))) != 0) {
|
|
BFL_LOGE(TAG, "failed! mbedtls_ssl_setup returned -0x%x", -ret);
|
|
return SSL_CONNECTION_ERROR;
|
|
}
|
|
if ((ret = mbedtls_ssl_set_hostname(&(tlsDataParams->ssl), pNetwork->tlsConnectParams.pDestinationURL)) != 0) {
|
|
BFL_LOGE(TAG, "failed! mbedtls_ssl_set_hostname returned %d", ret);
|
|
return SSL_CONNECTION_ERROR;
|
|
}
|
|
BFL_LOGD(TAG, "SSL state connect : %d ", tlsDataParams->ssl.state);
|
|
mbedtls_ssl_set_bio(&(tlsDataParams->ssl), &(tlsDataParams->server_fd), mbedtls_net_send, NULL, mbedtls_net_recv_timeout);
|
|
|
|
BFL_LOGD(TAG, "ok");
|
|
BFL_LOGD(TAG, "SSL state connect : %d ", tlsDataParams->ssl.state);
|
|
BFL_LOGD(TAG, "Performing the SSL/TLS handshake...");
|
|
while ((ret = mbedtls_ssl_handshake(&(tlsDataParams->ssl))) != 0) {
|
|
if(ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
|
|
BFL_LOGE(TAG, "failed! mbedtls_ssl_handshake returned -0x%x", -ret);
|
|
if(ret == MBEDTLS_ERR_X509_CERT_VERIFY_FAILED) {
|
|
BFL_LOGE(TAG, " Unable to verify the server's certificate. ");
|
|
}
|
|
return SSL_CONNECTION_ERROR;
|
|
}
|
|
}
|
|
|
|
BFL_LOGD(TAG, "ok [ Protocol is %s ] [ Ciphersuite is %s ]", mbedtls_ssl_get_version(&(tlsDataParams->ssl)), mbedtls_ssl_get_ciphersuite(&(tlsDataParams->ssl)));
|
|
if ((ret = mbedtls_ssl_get_record_expansion(&(tlsDataParams->ssl))) >= 0) {
|
|
BFL_LOGD(TAG, " [ Record expansion is %d ]", ret);
|
|
} else {
|
|
BFL_LOGD(TAG, " [ Record expansion is unknown (compression) ]");
|
|
}
|
|
|
|
BFL_LOGD(TAG, "Verifying peer X.509 certificate...");
|
|
if (pNetwork->tlsConnectParams.ServerVerificationFlag == true) {
|
|
if ((tlsDataParams->flags = mbedtls_ssl_get_verify_result(&(tlsDataParams->ssl))) != 0) {
|
|
BFL_LOGE(TAG, "failed");
|
|
mbedtls_x509_crt_verify_info(info_buf, sizeof(info_buf), " ! ", tlsDataParams->flags);
|
|
BFL_LOGE(TAG, "%s", info_buf);
|
|
ret = SSL_CONNECTION_ERROR;
|
|
} else {
|
|
BFL_LOGD(TAG, "ok");
|
|
ret = SUCCESS;
|
|
}
|
|
} else {
|
|
BFL_LOGW(TAG, " Server Verification skipped");
|
|
ret = SUCCESS;
|
|
}
|
|
|
|
if (mbedtls_ssl_get_peer_cert(&(tlsDataParams->ssl)) != NULL) {
|
|
BFL_LOGD(TAG, "Peer certificate information:");
|
|
mbedtls_x509_crt_info((char *) info_buf, sizeof(info_buf) - 1, " ", mbedtls_ssl_get_peer_cert(&(tlsDataParams->ssl)));
|
|
BFL_LOGD(TAG, "%s", info_buf);
|
|
}
|
|
return (IoT_Error_t) ret;
|
|
}
|
|
|
|
IoT_Error_t iot_tls_write(Network *pNetwork, unsigned char *pMsg, size_t len, Timer *timer, size_t *written_len)
|
|
{
|
|
size_t written_so_far;
|
|
bool isErrorFlag = false;
|
|
int frags, ret = 0;
|
|
TLSDataParams *tlsDataParams = &(pNetwork->tlsDataParams);
|
|
|
|
for (written_so_far = 0, frags = 0; written_so_far < len && !has_timer_expired(timer); written_so_far += ret, frags++) {
|
|
while (!has_timer_expired(timer) && (ret = mbedtls_ssl_write(&(tlsDataParams->ssl), pMsg + written_so_far, len - written_so_far)) <= 0) {
|
|
if (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
|
|
BFL_LOGE(TAG, "failed! mbedtls_ssl_write returned -0x%x", -ret);
|
|
/* All other negative return values indicate connection needs to be reset.
|
|
* Will be caught in ping request so ignored here */
|
|
isErrorFlag = true;
|
|
break;
|
|
}
|
|
}
|
|
if (isErrorFlag) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
*written_len = written_so_far;
|
|
if (isErrorFlag) {
|
|
return NETWORK_SSL_WRITE_ERROR;
|
|
} else if(has_timer_expired(timer) && written_so_far != len) {
|
|
return NETWORK_SSL_WRITE_TIMEOUT_ERROR;
|
|
}
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
IoT_Error_t iot_tls_read(Network *pNetwork, unsigned char *pMsg, size_t len, Timer *timer, size_t *read_len)
|
|
{
|
|
TLSDataParams *tlsDataParams = &(pNetwork->tlsDataParams);
|
|
mbedtls_ssl_context *ssl = &(tlsDataParams->ssl);
|
|
mbedtls_ssl_config *ssl_conf = &(tlsDataParams->conf);
|
|
uint32_t read_timeout;
|
|
size_t rxLen = 0;
|
|
int ret;
|
|
|
|
read_timeout = ssl_conf->read_timeout;
|
|
|
|
while (len > 0) {
|
|
/* Make sure we never block on read for longer than timer has left,
|
|
but also that we don't block indefinitely (ie read_timeout > 0) */
|
|
mbedtls_ssl_conf_read_timeout(ssl_conf, MAX(1, MIN(read_timeout, left_ms(timer))));
|
|
|
|
ret = mbedtls_ssl_read(ssl, pMsg, len);
|
|
/* Restore the old timeout */
|
|
mbedtls_ssl_conf_read_timeout(ssl_conf, read_timeout);
|
|
|
|
if (ret > 0) {
|
|
rxLen += ret;
|
|
pMsg += ret;
|
|
len -= ret;
|
|
} else if (ret == 0 || (ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE && ret != MBEDTLS_ERR_SSL_TIMEOUT)) {
|
|
return NETWORK_SSL_READ_ERROR;
|
|
}
|
|
|
|
// Evaluate timeout after the read to make sure read is done at least once
|
|
if (has_timer_expired(timer)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (len == 0) {
|
|
*read_len = rxLen;
|
|
return SUCCESS;
|
|
}
|
|
|
|
if (rxLen == 0) {
|
|
return NETWORK_SSL_NOTHING_TO_READ;
|
|
} else {
|
|
return NETWORK_SSL_READ_TIMEOUT_ERROR;
|
|
}
|
|
}
|
|
|
|
IoT_Error_t iot_tls_disconnect(Network *pNetwork)
|
|
{
|
|
mbedtls_ssl_context *ssl = &(pNetwork->tlsDataParams.ssl);
|
|
int ret = 0;
|
|
|
|
do {
|
|
ret = mbedtls_ssl_close_notify(ssl);
|
|
} while(ret == MBEDTLS_ERR_SSL_WANT_WRITE);
|
|
|
|
/* All other negative return values indicate connection needs to be reset.
|
|
* No further action required since this is disconnect call */
|
|
return SUCCESS;
|
|
}
|
|
|
|
IoT_Error_t iot_tls_destroy(Network *pNetwork)
|
|
{
|
|
TLSDataParams *tlsDataParams = &(pNetwork->tlsDataParams);
|
|
|
|
mbedtls_net_free(&(tlsDataParams->server_fd));
|
|
mbedtls_x509_crt_free(&(tlsDataParams->clicert));
|
|
mbedtls_x509_crt_free(&(tlsDataParams->cacert));
|
|
mbedtls_pk_free(&(tlsDataParams->pkey));
|
|
mbedtls_ssl_free(&(tlsDataParams->ssl));
|
|
mbedtls_ssl_config_free(&(tlsDataParams->conf));
|
|
mbedtls_ctr_drbg_free(&(tlsDataParams->ctr_drbg));
|
|
mbedtls_entropy_free(&(tlsDataParams->entropy));
|
|
|
|
return SUCCESS;
|
|
}
|