granicus.if.org Git - esp-idf/blob - components/esp-tls/esp-tls.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <stdlib.h>
   4 #include <unistd.h>
   5
   6 #include <sys/types.h>
   7 #include <sys/socket.h>
   8 #include <netdb.h>
   9
  10 #include <http_parser.h>
  11 #include "esp-tls.h"
  12
  13
  14 static const char *TAG = "esp-tls";
  15
  16 #ifdef ESP_PLATFORM
  17 #include <esp_log.h>
  18 #else
  19 #define ESP_LOGD(TAG, ...) //printf(__VA_ARGS__);
  20 #define ESP_LOGE(TAG, ...) printf(__VA_ARGS__);
  21 #endif
  22
  23 static struct addrinfo *resolve_host_name(const char *host, size_t hostlen)
  24 {
  25     struct addrinfo hints;
  26     memset(&hints, 0, sizeof(hints));
  27     hints.ai_family = AF_UNSPEC;
  28     hints.ai_socktype = SOCK_STREAM;
  29
  30     char *use_host = strndup(host, hostlen);
  31     if (!use_host) {
  32         return NULL;
  33     }
  34
  35     ESP_LOGD(TAG, "host:%s: strlen %zu\n", use_host, hostlen);
  36     struct addrinfo *res;
  37     if (getaddrinfo(use_host, NULL, &hints, &res)) {
  38         ESP_LOGE(TAG, "couldn't get hostname for :%s:\n", use_host);
  39         free(use_host);
  40         return NULL;
  41     }
  42     free(use_host);
  43     return res;
  44 }
  45
  46 static ssize_t tcp_read(struct esp_tls *tls, char *data, size_t datalen)
  47 {
  48     return recv(tls->sockfd, data, datalen, 0);
  49 }
  50
  51 static ssize_t tls_read(struct esp_tls *tls, char *data, size_t datalen)
  52 {
  53     ssize_t ret = SSL_read(tls->ssl, data, datalen);
  54     if (ret < 0) {
  55         int err = SSL_get_error(tls->ssl, ret);
  56         if (err != SSL_ERROR_WANT_WRITE && err != SSL_ERROR_WANT_READ) {
  57             ESP_LOGE(TAG, "read error :%d:\n", ret);
  58         }
  59         return -err;
  60     }
  61     return ret;
  62 }
  63
  64 static int esp_tcp_connect(const char *host, int hostlen, int port)
  65 {
  66     struct addrinfo *res = resolve_host_name(host, hostlen);
  67     if (!res) {
  68         return -1;
  69     }
  70
  71     int ret = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
  72     if (ret < 0) {
  73         goto err_freeaddr;
  74     }
  75     int fd = ret;
  76
  77     void *addr_ptr;
  78     if (res->ai_family == AF_INET) {
  79         struct sockaddr_in *p = (struct sockaddr_in *)res->ai_addr;
  80         p->sin_port = htons(port);
  81         addr_ptr = p;
  82     } else if (res->ai_family == AF_INET6) {
  83         struct sockaddr_in6 *p = (struct sockaddr_in6 *)res->ai_addr;
  84         p->sin6_port = htons(port);
  85         p->sin6_family = AF_INET6;
  86         addr_ptr = p;
  87     } else {
  88         /* Unsupported Protocol Family */
  89         goto err_freesocket;
  90     }
  91
  92     ret = connect(fd, addr_ptr, res->ai_addrlen);
  93     if (ret < 0) {
  94         goto err_freesocket;
  95     }
  96
  97     freeaddrinfo(res);
  98     return fd;
  99
 100 err_freesocket:
 101     close(fd);
 102 err_freeaddr:
 103     freeaddrinfo(res);
 104     return -1;
 105 }
 106
 107 static int create_ssl_handle(struct esp_tls *tls, const char *hostname, size_t hostlen, struct esp_tls_cfg *cfg)
 108 {
 109     int ret;
 110
 111     SSL_CTX *ssl_ctx = SSL_CTX_new(TLSv1_2_client_method());
 112     if (!ssl_ctx) {
 113         return -1;
 114     }
 115 #ifdef __APPLE__
 116     SSL_CTX_set_options(ssl_ctx, SSL_OP_ALL | SSL_OP_NO_SSLv2);
 117     SSL_CTX_set_mode(ssl_ctx, SSL_MODE_AUTO_RETRY);
 118     SSL_CTX_set_mode(ssl_ctx, SSL_MODE_RELEASE_BUFFERS);
 119 #endif
 120
 121     if (cfg->cacert_pem_buf != NULL) {
 122         SSL_CTX_set_verify(ssl_ctx, SSL_VERIFY_PEER, NULL);
 123
 124         BIO *bio;
 125         bio = BIO_new(BIO_s_mem());
 126         BIO_write(bio, cfg->cacert_pem_buf, cfg->cacert_pem_bytes);
 127
 128         X509 *ca = PEM_read_bio_X509(bio, NULL, 0, NULL);
 129
 130         if (!ca) {
 131             ESP_LOGE(TAG, "CA Error\n");
 132         }
 133         ESP_LOGD(TAG, "CA OK\n");
 134
 135         X509_STORE_add_cert(SSL_CTX_get_cert_store(ssl_ctx), ca);
 136
 137         X509_free(ca);
 138         BIO_free(bio);
 139     }
 140
 141     if (cfg->alpn_protos) {
 142         SSL_CTX_set_alpn_protos(ssl_ctx, cfg->alpn_protos, strlen((char *)cfg->alpn_protos));
 143     }
 144     SSL *ssl = SSL_new(ssl_ctx);
 145     if (!ssl) {
 146         SSL_CTX_free(ssl_ctx);
 147         return -1;
 148     }
 149
 150     char *use_host = strndup(hostname, hostlen);
 151     if (!use_host) {
 152         SSL_CTX_free(ssl_ctx);
 153         return -1;
 154     }
 155     SSL_set_tlsext_host_name(ssl, use_host);
 156     free(use_host);
 157
 158     SSL_set_fd(ssl, tls->sockfd);
 159     ret = SSL_connect(ssl);
 160     if (ret < 1) {
 161         ESP_LOGE(TAG, "SSL handshake failed");
 162         SSL_free(ssl);
 163         SSL_CTX_free(ssl_ctx);
 164         return -1;
 165     }
 166
 167     tls->ctx = ssl_ctx;
 168     tls->ssl = ssl;
 169     return 0;
 170 }
 171
 172 void esp_tls_conn_delete(struct esp_tls *tls)
 173 {
 174     if (!tls) {
 175         return;
 176     }
 177     if (tls->ssl) {
 178         SSL_free(tls->ssl);
 179     }
 180     if (tls->ctx) {
 181         SSL_CTX_free(tls->ctx);
 182     }
 183     if (tls->sockfd) {
 184         close(tls->sockfd);
 185     }
 186     free(tls);
 187 };
 188
 189 static ssize_t tcp_write(struct esp_tls *tls, const char *data, size_t datalen)
 190 {
 191     return send(tls->sockfd, data, datalen, 0);
 192 }
 193
 194 static ssize_t tls_write(struct esp_tls *tls, const char *data, size_t datalen)
 195 {
 196     ssize_t ret = SSL_write(tls->ssl, data, datalen);
 197     if (ret < 0) {
 198         int err = SSL_get_error(tls->ssl, ret);
 199         if (err != SSL_ERROR_WANT_WRITE && err != SSL_ERROR_WANT_READ) {
 200             ESP_LOGE(TAG, "write error :%d:\n", ret);
 201         }
 202         return -err;
 203     }
 204     return ret;
 205 }
 206
 207 struct esp_tls *esp_tls_conn_new(const char *hostname, int hostlen, int port, struct esp_tls_cfg *cfg)
 208 {
 209     int sockfd = esp_tcp_connect(hostname, hostlen, port);
 210     if (sockfd < 0) {
 211         return NULL;
 212     }
 213
 214     struct esp_tls *tls = (struct esp_tls *)calloc(1, sizeof(struct esp_tls));
 215     if (!tls) {
 216         close(sockfd);
 217         return NULL;
 218     }
 219     tls->sockfd = sockfd;
 220     tls->read = tcp_read;
 221     tls->write = tcp_write;
 222
 223     if (cfg) {
 224         if (create_ssl_handle(tls, hostname, hostlen, cfg) != 0) {
 225             esp_tls_conn_delete(tls);
 226             return NULL;
 227         }
 228         tls->read = tls_read;
 229         tls->write = tls_write;
 230     }
 231     return tls;
 232 }
 233
 234 static int get_port(const char *url, struct http_parser_url *u)
 235 {
 236     if (u->field_data[UF_PORT].len) {
 237         return strtol(&url[u->field_data[UF_PORT].off], NULL, 10);
 238     } else {
 239         if (strncmp(&url[u->field_data[UF_SCHEMA].off], "http", u->field_data[UF_SCHEMA].len) == 0) {
 240             return 80;
 241         } else if (strncmp(&url[u->field_data[UF_SCHEMA].off], "https", u->field_data[UF_SCHEMA].len) == 0) {
 242             return 443;
 243         }
 244     }
 245     return 0;
 246 }
 247
 248 struct esp_tls *esp_tls_conn_http_new(const char *url, struct esp_tls_cfg *cfg)
 249 {
 250     /* Parse URI */
 251     struct http_parser_url u;
 252     http_parser_url_init(&u);
 253     http_parser_parse_url(url, strlen(url), 0, &u);
 254
 255     /* Connect to host */
 256     return esp_tls_conn_new(&url[u.field_data[UF_HOST].off], u.field_data[UF_HOST].len,
 257                             get_port(url, &u), cfg);
 258 }