resource/csdk/connectivity/src/adapter_util/ca_adapter_net_tls.c

   1 /******************************************************************
   2  *
   3  * Copyright 2016 Samsung Electronics All Rights Reserved.
   4  *
   5  *
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  ******************************************************************/
  20
  21 #define _GNU_SOURCE
  22
  23 #include <stddef.h>
  24 #include "ca_adapter_net_tls.h"
  25 #include "cacommon.h"
  26 #include "caipinterface.h"
  27 #include "oic_malloc.h"
  28 #include "pkix/byte_array.h"
  29 #include "camutex.h"
  30
  31 // headers required for mbed TLS
  32 #include "mbedtls/platform.h"
  33 #include "mbedtls/ssl.h"
  34 #include "mbedtls/entropy.h"
  35 #include "mbedtls/ctr_drbg.h"
  36 #include "mbedtls/pkcs12.h"
  37 #include "mbedtls/ssl_internal.h"
  38
  39 #ifndef NDEBUG
  40 #include "mbedtls/debug.h"
  41 #include "mbedtls/version.h"
  42 #endif
  43
  44 #ifdef __unix__
  45 #include <sys/types.h>
  46 #include <sys/stat.h>
  47 #include <fcntl.h>
  48 #include <unistd.h>
  49 #endif
  50
  51 #include "pkix/byte_array.h"
  52
  53 /**
  54  * @def MBED_TLS_VERSION_LEN
  55  * @brief mbedTLS version string length
  56  */
  57 #define MBED_TLS_VERSION_LEN (16)
  58 /**
  59  * @def SEED
  60  * @brief Seed for initialization RNG
  61  */
  62 #define SEED "IOTIVITY_RND"
  63 /**
  64  * @def UUID_PREFIX
  65  * @brief uuid prefix in certificate subject field
  66  */
  67 #define UUID_PREFIX "uuid:"
  68 /**
  69  * @def USERID_PREFIX
  70  * @brief userid prefix in certificate alternative subject name field
  71  */
  72 #define USERID_PREFIX "userid:"
  73
  74 /**
  75  * @def NET_TLS_TAG
  76  * @brief Logging tag for module name
  77  */
  78 #define NET_TLS_TAG "OIC_CA_NET_TLS"
  79 /**
  80  * @def MBED_TLS_TAG
  81  * @brief Logging tag for mbedTLS library
  82  */
  83 #define MBED_TLS_TAG "OIC_MBED_TLS"
  84 /**
  85  * @def MMBED_TLS_DEBUG_LEVEL
  86  * @brief Logging level for mbedTLS library
  87  */
  88 #define MBED_TLS_DEBUG_LEVEL (4) // Verbose
  89
  90 /**
  91  * @def TLS_MSG_BUF_LEN
  92  * @brief Buffer size for TLS record. A single TLS record may be up to 16384 octets in length
  93  */
  94
  95 #define TLS_MSG_BUF_LEN (16384)
  96 /**
  97  * @def PSK_LENGTH
  98  * @brief PSK keys max length
  99  */
 100 #define PSK_LENGTH (256/8)
 101 /**
 102  * @def UUID_LENGTHPSK_LENGTH
 103  * @brief Identity max length
 104  */
 105 #define UUID_LENGTH (128/8)
 106 /**
 107  * @def MASTER_SECRET_LEN
 108  * @brief TLS master secret length
 109  */
 110 #define MASTER_SECRET_LEN (48)
 111
 112 #define TLS_CLOSE_NOTIFY(peer, ret)                                                                \
 113 do                                                                                                 \
 114 {                                                                                                  \
 115     ret = mbedtls_ssl_close_notify(&peer->ssl);                                                    \
 116 } while (MBEDTLS_ERR_SSL_WANT_WRITE == ret)
 117
 118 #define TLS_RET_HANDSHAKE_RES(peer)                                                                \
 119 if (g_tlsHandshakeCallback)                                                                        \
 120 {                                                                                                  \
 121     CAErrorInfo_t errorInfo = {.result = CA_STATUS_FAILED};                                        \
 122     g_tlsHandshakeCallback(&peer->sep.endpoint, &errorInfo);                                       \
 123 }
 124
 125 #define TLS_CHECK_HANDSHAKE_FAIL(peer, ret, str, mutex, error)                                     \
 126 if (0 != ret && MBEDTLS_ERR_SSL_WANT_READ != ret &&  MBEDTLS_ERR_SSL_WANT_WRITE != ret)            \
 127 {                                                                                                  \
 128     OIC_LOG_V(ERROR, NET_TLS_TAG, "%s: -0x%x", str, -ret);                                         \
 129     TLS_CLOSE_NOTIFY(peer, ret);                                                                   \
 130     TLS_RET_HANDSHAKE_RES(peer);                                                                   \
 131     removePeerFromList(&peer->sep.endpoint);                                                       \
 132     if (mutex)                                                                                     \
 133     {                                                                                              \
 134         ca_mutex_unlock(g_tlsContextMutex);                                                        \
 135     }                                                                                              \
 136     return error;                                                                                  \
 137 }
 138
 139 typedef enum
 140 {
 141     ADAPTER_TLS_RSA_WITH_AES_256_CBC_SHA,
 142     ADAPTER_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8,
 143     ADAPTER_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA_256,
 144     ADAPTER_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
 145     ADAPTER_CIPHER_MAX
 146 } AdapterCipher_t;
 147
 148 typedef enum
 149 {
 150     ADAPTER_CURVE_SECP256R1,
 151     ADAPTER_CURVE_MAX
 152 } AdapterCurve_t;
 153
 154 int tlsCipher[ADAPTER_CIPHER_MAX][2] =
 155 {
 156     {MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA, 0},
 157     {MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8, 0},
 158     {MBEDTLS_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA256, 0},
 159     {MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256, 0}
 160 };
 161
 162 mbedtls_ecp_group_id curve[ADAPTER_CURVE_MAX][2] =
 163 {
 164     {MBEDTLS_ECP_DP_SECP256R1, 0}
 165 };
 166
 167 //TODO add description
 168 static PkiInfo_t g_pkiInfo = {{NULL, 0}, {NULL, 0}, {NULL, 0}, {NULL, 0}};
 169
 170 #ifndef NDEBUG
 171 /**
 172  * Pass a message to the OIC logger.
 173  *
 174  * @param[in] ctx  opaque context for the callback
 175  * @param[in] level  debug level
 176  * @param[in] file  file name
 177  * @param[in] line  line number
 178  * @param[in] str  message
 179  */
 180 static void debugTls(void *ctx, int level, const char *file, int line, const char *str)
 181 {
 182     ((void) level);
 183     ((void) file);
 184     ((void) line);
 185
 186     OIC_LOG_V(DEBUG, MBED_TLS_TAG, "%s", str);
 187     fflush((FILE *) ctx);
 188 }
 189 #endif
 190
 191 /**
 192  * structure to holds the information of cache message and address info.
 193  */
 194 typedef ByteArray TlsCacheMessage_t;
 195
 196
 197 /**
 198  * Data structure for holding the send and recv callbacks.
 199  */
 200 typedef struct TlsCallBacks
 201 {
 202     CAPacketReceivedCallback recvCallback;  /**< Callback used to send data to upper layer. */
 203     CAPacketSendCallback sendCallback;      /**< Callback used to send data to socket layer. */
 204 } TlsCallbacks_t;
 205
 206 /**
 207  * Data structure for holding the mbedTLS interface related info.
 208  */
 209 typedef struct TlsContext
 210 {
 211     u_arraylist_t *peerList;         /**< peer list which holds the mapping between
 212                                               peer id, it's n/w address and mbedTLS context. */
 213     mbedtls_entropy_context entropy;
 214     mbedtls_ctr_drbg_context rnd;
 215     mbedtls_x509_crt ca;
 216     mbedtls_x509_crt crt;
 217     mbedtls_pk_context pkey;
 218     mbedtls_ssl_config clientConf;
 219     mbedtls_ssl_config serverConf;
 220     AdapterCipher_t cipher;
 221     TlsCallbacks_t adapterCallbacks[MAX_SUPPORTED_ADAPTERS];
 222     mbedtls_x509_crl crl;
 223
 224 } TlsContext_t;
 225
 226 /**
 227  * @var g_caTlsContext
 228  * @brief global context which holds tls context and cache list information.
 229  */
 230 static TlsContext_t * g_caTlsContext = NULL;
 231
 232 /**
 233  * @var g_getCredentialsCallback
 234  * @brief callback to get TLS credentials (same as for DTLS)
 235  */
 236 static CAGetDTLSPskCredentialsHandler g_getCredentialsCallback = NULL;
 237
 238 /**
 239  * @var g_getPkixInfoCallback
 240  *
 241  * @brief callback to get X.509-based Public Key Infrastructure
 242  */
 243 static CAgetPkixInfoHandler g_getPkixInfoCallback = NULL;
 244
 245 /**
 246  * @var g_dtlsContextMutex
 247  * @brief Mutex to synchronize access to g_caTlsContext.
 248  */
 249 static ca_mutex g_tlsContextMutex = NULL;
 250
 251 /**
 252  * @var g_tlsHandshakeCallback
 253  * @brief callback to deliver the TLS handshake result
 254  */
 255 static CAErrorCallback g_tlsHandshakeCallback = NULL;
 256
 257 /**
 258  * Data structure for holding the data to be rceived.
 259  */
 260 typedef struct TlsRecBuf
 261 {
 262     uint8_t * buff;
 263     size_t len;
 264     size_t loaded;
 265 } TlsRecBuf_t;
 266
 267 /**
 268  * Data structure for holding the data related to endpoint
 269  * and TLS session.
 270  */
 271 typedef struct TlsEndPoint
 272 {
 273     mbedtls_ssl_context ssl;
 274     CASecureEndpoint_t sep;
 275     u_arraylist_t * cacheList;
 276     TlsRecBuf_t recBuf;
 277     uint8_t master[MASTER_SECRET_LEN];
 278 } TlsEndPoint_t;
 279
 280 void CAsetTlsCredentialsCallback(CAGetDTLSPskCredentialsHandler credCallback)
 281 {
 282     // TODO Does this method needs protection of tlsContextMutex?
 283     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
 284     g_getCredentialsCallback = credCallback;
 285     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 286 }
 287
 288 void CAsetPkixInfoCallback(CAgetPkixInfoHandler infoCallback)
 289 {
 290     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
 291     g_getPkixInfoCallback = infoCallback;
 292     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 293 }
 294 /**
 295  * Write callback.
 296  *
 297  * @param[in]  tep    TLS endpoint
 298  * @param[in]  data    message
 299  * @param[in]  dataLen    message length
 300  *
 301  * @return  message length
 302  */
 303 static int sendTls(void * tep, const unsigned char * data, size_t dataLen)
 304 {
 305     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
 306     VERIFY_NON_NULL_RET(tep, NET_TLS_TAG, "secure endpoint is NULL", 0);
 307     VERIFY_NON_NULL_RET(data, NET_TLS_TAG, "data is NULL", 0);
 308     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Data len: %zu", dataLen);
 309
 310     g_caTlsContext->adapterCallbacks[0].sendCallback(&(((TlsEndPoint_t * )tep)->sep.endpoint),
 311             (const void *) data, (uint32_t) dataLen);
 312     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 313     return dataLen;
 314 }
 315 /**
 316  * Read callback.
 317  *
 318  * @param[in]  tep    TLS endpoint
 319  * @param[in]  data    message
 320  * @param[in]  dataLen    message length
 321  *
 322  * @return  read length
 323  */
 324 static int recvTls(void * tep, unsigned char * data, size_t dataLen)
 325 {
 326     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
 327     VERIFY_NON_NULL_RET(tep, NET_TLS_TAG, "endpoint is NULL", 0);
 328     VERIFY_NON_NULL_RET(data, NET_TLS_TAG, "data is NULL", 0);
 329
 330     TlsRecBuf_t *recBuf = &((TlsEndPoint_t *)tep)->recBuf;
 331     size_t retLen = (recBuf->len > recBuf->loaded ? recBuf->len - recBuf->loaded : 0);
 332     retLen = (retLen < dataLen ? retLen : dataLen);
 333
 334     memcpy(data, recBuf->buff + recBuf->loaded, retLen);
 335     recBuf->loaded += retLen;
 336
 337     OIC_LOG_BUFFER(DEBUG, NET_TLS_TAG, data, retLen);
 338     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 339     return (int)retLen;
 340 }
 341
 342 //TODO add description
 343 static int parseChain(mbedtls_x509_crt * crt, const unsigned char * buf, int buflen)
 344 {
 345     VERIFY_NON_NULL_RET(crt, NET_TLS_TAG, "Param crt is NULL" , -1);
 346     VERIFY_NON_NULL_RET(buf, NET_TLS_TAG, "Param buf is NULL" , -1);
 347
 348     int pos = 0;
 349     int len = 0;
 350     int ret = 0;
 351     while (pos < buflen)
 352     {
 353         if (0x30 == buf[pos] && 0x82 == buf[pos + 1] && pos + 3 < buflen)
 354         {
 355             len = (((int) buf[pos+2]) << 8) | buf[pos+3];
 356             if (pos + len < buflen)
 357             {
 358                 ret = mbedtls_x509_crt_parse_der(crt, buf+pos, len+4);
 359                 if( 0 != ret)
 360                 {
 361                     OIC_LOG_V(ERROR, NET_TLS_TAG, "mbedtls_x509_crt_parse returned -0x%x", -ret);
 362                     return -1;
 363                 }
 364             }
 365             pos += len + 4;
 366         }
 367         else
 368         {
 369              OIC_LOG_V(ERROR, NET_TLS_TAG, "mbedtls_x509_crt_parse returned -0x%x", -ret);
 370              return -1;
 371         }
 372     }
 373     return 0;
 374 }
 375 //TODO add description
 376 static int loadX509()
 377 {
 378     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
 379     VERIFY_NON_NULL_RET(g_getPkixInfoCallback, NET_TLS_TAG, "PKIX info callback is NULL", -1);
 380
 381     g_getPkixInfoCallback(&g_pkiInfo);
 382
 383     int ret = parseChain(&g_caTlsContext->ca, g_pkiInfo.ca.data, g_pkiInfo.ca.len);
 384     if(0 != ret)
 385     {
 386         OIC_LOG(ERROR, NET_TLS_TAG, "CA chain parsing error");
 387         OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 388         return -1;
 389     }
 390     ret = parseChain(&g_caTlsContext->crt, g_pkiInfo.crt.data, g_pkiInfo.crt.len);
 391     if(0 != ret)
 392     {
 393         OIC_LOG(ERROR, NET_TLS_TAG, "Own certificate chain parsing error");
 394         OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 395         return -1;
 396     }
 397
 398     ret =  mbedtls_pk_parse_key(&g_caTlsContext->pkey, g_pkiInfo.key.data, g_pkiInfo.key.len,
 399                                                                                            NULL, 0);
 400     if(0 != ret)
 401     {
 402         OIC_LOG(ERROR, NET_TLS_TAG, "Key parsing error");
 403         OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 404         return -1;
 405     }
 406     ret = mbedtls_x509_crl_parse_der(&g_caTlsContext->crl, g_pkiInfo.crl.data, g_pkiInfo.crl.len);
 407     if(0 != ret)
 408     {
 409         OIC_LOG(ERROR, NET_TLS_TAG, "CRL parsing error");
 410         OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 411         //TODO
 412         //return -1;
 413     }
 414
 415     mbedtls_ssl_conf_ca_chain(&g_caTlsContext->clientConf, &g_caTlsContext->ca, NULL);
 416     mbedtls_ssl_conf_ca_chain(&g_caTlsContext->serverConf, &g_caTlsContext->ca, NULL);
 417
 418     ret = mbedtls_ssl_conf_own_cert(&g_caTlsContext->serverConf, &g_caTlsContext->crt,
 419                                                                              &g_caTlsContext->pkey);
 420     if(0 != ret)
 421     {
 422         OIC_LOG(ERROR, NET_TLS_TAG, "Certificate parsing error");
 423         OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 424         return -1;
 425     }
 426     ret = mbedtls_ssl_conf_own_cert( &g_caTlsContext->clientConf, &g_caTlsContext->crt,
 427                                                                              &g_caTlsContext->pkey);
 428     if(0 != ret)
 429     {
 430         OIC_LOG(ERROR, NET_TLS_TAG, "Certificate parsing error");
 431         OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 432         return -1;
 433     }
 434
 435     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 436     return 0;
 437 }
 438
 439 /*
 440  * PSK callback.
 441  *
 442  * @param[in]  notUsed     opaque context
 443  * @param[in]  ssl    mbedTLS context
 444  * @param[in]  desc    identity
 445  * @param[in]  descLen    identity length
 446  *
 447  * @return  0 on success any other return value will result in a denied PSK identity
 448  */
 449 static int getTlsCredentialsCallback(void * notUsed, mbedtls_ssl_context * ssl,
 450                                      const unsigned char * desc, size_t descLen)
 451 {
 452     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
 453     VERIFY_NON_NULL_RET(g_getCredentialsCallback, NET_TLS_TAG, "Credential callback s NULL", -1);
 454     VERIFY_NON_NULL_RET(ssl, NET_TLS_TAG, "ssl pointer is NULL", -1);
 455     VERIFY_NON_NULL_RET(desc, NET_TLS_TAG, "desc pointer is NULL", -1);
 456     if (descLen > CA_MAX_ENDPOINT_IDENTITY_LEN)
 457     {
 458         OIC_LOG(ERROR, NET_TLS_TAG, "desc too long!");
 459         return -1;
 460     }
 461     (void) notUsed;
 462     uint8_t keyBuf[PSK_LENGTH] = {0};
 463
 464     // Retrieve the credentials blob from security module
 465     int ret = g_getCredentialsCallback(2, desc, descLen, keyBuf, PSK_LENGTH);
 466     if (ret > 0)
 467     {
 468         memcpy(((TlsEndPoint_t *) ssl)->sep.identity.id, desc, descLen);
 469         ((TlsEndPoint_t *) ssl)->sep.identity.id_length = descLen;
 470
 471         OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 472         return(mbedtls_ssl_set_hs_psk(ssl, keyBuf, PSK_LENGTH));
 473     }
 474     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 475     return -1;
 476 }
 477 /**
 478  * Gets session corresponding for endpoint.
 479  *
 480  * @param[in]  peer    remote address
 481  *
 482  * @return  TLS session or NULL
 483  */
 484 static TlsEndPoint_t *getTlsPeer(const CAEndpoint_t *peer)
 485 {
 486     uint32_t listIndex = 0;
 487     uint32_t listLength = 0;
 488     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
 489     VERIFY_NON_NULL_RET(peer, NET_TLS_TAG, "TLS peer is NULL", NULL);
 490
 491     TlsEndPoint_t *tep = NULL;
 492     listLength = u_arraylist_length(g_caTlsContext->peerList);
 493     for (listIndex = 0; listIndex < listLength; listIndex++)
 494     {
 495         tep = (TlsEndPoint_t *) u_arraylist_get(g_caTlsContext->peerList, listIndex);
 496         if (NULL == tep)
 497         {
 498             continue;
 499         }
 500         OIC_LOG_V(DEBUG, NET_TLS_TAG, "Compare [%s] and [%s]", peer->addr, tep->sep.endpoint.addr);
 501         if((0 == strncmp(peer->addr, tep->sep.endpoint.addr, MAX_ADDR_STR_SIZE_CA))
 502                 && (peer->port == tep->sep.endpoint.port))
 503         {
 504             OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 505             return tep;
 506         }
 507     }
 508     OIC_LOG(DEBUG, NET_TLS_TAG, "Return NULL");
 509     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 510     return NULL;
 511 }
 512 /**
 513  * Deletes cached message.
 514  *
 515  * @param[in]  msg    message
 516  */
 517 static void deleteTlsCacheMessage(TlsCacheMessage_t * msg)
 518 {
 519     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
 520     VERIFY_NON_NULL_VOID(msg, NET_TLS_TAG, "msg");
 521
 522     OICFree(msg->data);
 523     OICFree(msg);
 524
 525     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 526 }
 527 /**
 528  * Deletes cached message list.
 529  *
 530  * @param[in] cacheList  list of cached messages
 531  */
 532 static void deleteCacheList(u_arraylist_t * cacheList)
 533 {
 534     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
 535     VERIFY_NON_NULL_VOID(cacheList, NET_TLS_TAG, "cacheList");
 536     uint32_t listIndex = 0;
 537     uint32_t listLength = 0;
 538
 539     listLength = u_arraylist_length(cacheList);
 540     for (listIndex = 0; listIndex < listLength; listIndex++)
 541     {
 542         TlsCacheMessage_t * msg = (TlsCacheMessage_t *) u_arraylist_get(cacheList, listIndex);
 543         if (NULL != msg)
 544         {
 545             deleteTlsCacheMessage(msg);
 546         }
 547     }
 548     u_arraylist_free(&cacheList);
 549
 550     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 551 }
 552 /**
 553  * Deletes endpoint with session.
 554  *
 555  * @param[in]  tep    endpoint with session info
 556  */
 557 static void deleteTlsEndPoint(TlsEndPoint_t * tep)
 558 {
 559     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
 560     VERIFY_NON_NULL_VOID(tep, NET_TLS_TAG, "tep");
 561
 562     mbedtls_ssl_free(&tep->ssl);
 563     deleteCacheList(tep->cacheList);
 564     OICFree(tep);
 565     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 566 }
 567 /**
 568  * Removes endpoint session from list.
 569  *
 570  * @param[in]  endpoint    remote address
 571  */
 572 static void removePeerFromList(CAEndpoint_t * endpoint)
 573 {
 574     uint32_t listLength = u_arraylist_length(g_caTlsContext->peerList);
 575     VERIFY_NON_NULL_VOID(endpoint, NET_TLS_TAG, "endpoint");
 576     for (uint32_t listIndex = 0; listIndex < listLength; listIndex++)
 577     {
 578         TlsEndPoint_t * tep = (TlsEndPoint_t *)u_arraylist_get(g_caTlsContext->peerList,listIndex);
 579         if (NULL == tep)
 580         {
 581             continue;
 582         }
 583         if(0 == strncmp(endpoint->addr, tep->sep.endpoint.addr, MAX_ADDR_STR_SIZE_CA)
 584                 && (endpoint->port == tep->sep.endpoint.port))
 585         {
 586             u_arraylist_remove(g_caTlsContext->peerList, listIndex);
 587             deleteTlsEndPoint(tep);
 588             return;
 589         }
 590     }
 591 }
 592 /**
 593  * Deletes session list.
 594  */
 595 static void deletePeerList()
 596 {
 597     uint32_t listLength = u_arraylist_length(g_caTlsContext->peerList);
 598     for (uint32_t listIndex = 0; listIndex < listLength; listIndex++)
 599     {
 600         TlsEndPoint_t * tep = (TlsEndPoint_t *)u_arraylist_get(g_caTlsContext->peerList,listIndex);
 601         if (NULL == tep)
 602         {
 603             continue;
 604         }
 605         deleteTlsEndPoint(tep);
 606     }
 607     u_arraylist_free(&g_caTlsContext->peerList);
 608 }
 609
 610 CAResult_t CAcloseTlsConnection(const CAEndpoint_t *endpoint)
 611 {
 612     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
 613     VERIFY_NON_NULL_RET(endpoint, NET_TLS_TAG, "Param endpoint is NULL" , CA_STATUS_INVALID_PARAM);
 614
 615     ca_mutex_lock(g_tlsContextMutex);
 616     if (NULL == g_caTlsContext)
 617     {
 618         OIC_LOG(ERROR, NET_TLS_TAG, "Context is NULL");
 619         ca_mutex_unlock(g_tlsContextMutex);
 620         return CA_STATUS_FAILED;
 621     }
 622     TlsEndPoint_t * tep = getTlsPeer(endpoint);
 623     if (NULL == tep)
 624     {
 625         OIC_LOG(ERROR, NET_TLS_TAG, "Session does not exist");
 626         ca_mutex_unlock(g_tlsContextMutex);
 627         return CA_STATUS_FAILED;
 628     }
 629     /* No error checking, the connection might be closed already */
 630     int ret = 0;
 631     do
 632     {
 633         ret = mbedtls_ssl_close_notify(&tep->ssl);
 634     }
 635     while (MBEDTLS_ERR_SSL_WANT_WRITE == ret);
 636
 637     removePeerFromList(&tep->sep.endpoint);
 638     ca_mutex_unlock(g_tlsContextMutex);
 639
 640     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 641     return CA_STATUS_OK;
 642 }
 643 /**
 644  * Creates session for endpoint.
 645  *
 646  * @param[in]  endpoint    remote address
 647  * @param[in]  config    mbedTLS configuration info
 648  *
 649  * @return  TLS endpoint or NULL
 650  */
 651 static TlsEndPoint_t * newTlsEndPoint(const CAEndpoint_t * endpoint, mbedtls_ssl_config * config)
 652 {
 653     TlsEndPoint_t * tep = NULL;
 654     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
 655     VERIFY_NON_NULL_RET(endpoint, NET_TLS_TAG, "endpoint", NULL);
 656     VERIFY_NON_NULL_RET(config, NET_TLS_TAG, "config", NULL);
 657
 658     tep = (TlsEndPoint_t *) OICCalloc(1, sizeof (TlsEndPoint_t));
 659     if (NULL == tep)
 660     {
 661         OIC_LOG(ERROR, NET_TLS_TAG, "Malloc failed!");
 662         return NULL;
 663     }
 664
 665     tep->sep.endpoint = *endpoint;
 666     tep->sep.endpoint.flags |= CA_SECURE;
 667
 668     if(0 != mbedtls_ssl_setup( &tep->ssl, config))
 669     {
 670         OIC_LOG(ERROR, NET_TLS_TAG, "Setup failed");
 671         OICFree(tep);
 672         OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 673         return NULL;
 674     }
 675
 676     mbedtls_ssl_set_bio(&tep->ssl, tep, sendTls, recvTls, NULL);
 677
 678     tep->cacheList = u_arraylist_create();
 679     if (NULL == tep->cacheList)
 680     {
 681         OIC_LOG(ERROR, NET_TLS_TAG, "cacheList initialization failed!");
 682         mbedtls_ssl_free(&tep->ssl);
 683         OICFree(tep);
 684         OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 685         return NULL;
 686     }
 687     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 688     return tep;
 689 }
 690 /**
 691  * Initializes PSK identity.
 692  *
 693  * @param[out]  config    client/server config to be updated
 694  *
 695  * @return  0 on success or -1 on error
 696  */
 697 static int initPskIdentity(mbedtls_ssl_config * config)
 698 {
 699     uint8_t idBuf[UUID_LENGTH] = {0};
 700     VERIFY_NON_NULL_RET(config, NET_TLS_TAG, "Param config is NULL" , -1);
 701
 702     if (0 > g_getCredentialsCallback(CA_DTLS_PSK_IDENTITY, NULL, 0, idBuf, UUID_LENGTH))
 703     {
 704         OIC_LOG(ERROR, NET_TLS_TAG, "Identity not found");
 705         return -1;
 706     }
 707     if (0 != mbedtls_ssl_conf_psk(config, idBuf, 0, idBuf, UUID_LENGTH))
 708     {
 709         OIC_LOG(ERROR, NET_TLS_TAG, "Identity initialization failed!");
 710         return -1;
 711     }
 712     return 0;
 713 }
 714 /**
 715  * Initiate TLS handshake with endpoint.
 716  *
 717  * @param[in]  endpoint    remote address
 718  *
 719  * @return  TLS endpoint or NULL
 720  */
 721 static TlsEndPoint_t * initiateTlsHandshake(const CAEndpoint_t *endpoint)
 722 {
 723     int ret = 0;
 724     TlsEndPoint_t * tep = NULL;
 725
 726     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
 727     VERIFY_NON_NULL_RET(endpoint, NET_TLS_TAG, "Param endpoint is NULL" , NULL);
 728
 729     // Retrieve the credentials blob from security module
 730     if (ADAPTER_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 == g_caTlsContext->cipher &&
 731             0 != initPskIdentity(&g_caTlsContext->clientConf))
 732     {
 733         OIC_LOG(ERROR, NET_TLS_TAG, "Client PSK identity initialization failed!");
 734         return NULL;
 735     }
 736
 737     tep = newTlsEndPoint(endpoint, &g_caTlsContext->clientConf);
 738     if (NULL == tep)
 739     {
 740         OIC_LOG(ERROR, NET_TLS_TAG, "Malloc failed!");
 741         return NULL;
 742     }
 743
 744     if (ADAPTER_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8 == g_caTlsContext->cipher ||
 745         ADAPTER_TLS_RSA_WITH_AES_256_CBC_SHA == g_caTlsContext->cipher)
 746     {
 747         ret = loadX509();
 748         if (0 != ret)
 749         {
 750             OIC_LOG(ERROR, NET_TLS_TAG, "Failed to init X.509");
 751             deleteTlsEndPoint(tep);
 752             return NULL;
 753         }
 754     }
 755
 756     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Add %s:%d", tep->sep.endpoint.addr, tep->sep.endpoint.port);
 757     ret = u_arraylist_add(g_caTlsContext->peerList, (void *) tep);
 758     if (!ret)
 759     {
 760         OIC_LOG(ERROR, NET_TLS_TAG, "u_arraylist_add failed!");
 761         deleteTlsEndPoint(tep);
 762         return NULL;
 763     }
 764
 765     while (MBEDTLS_SSL_HANDSHAKE_OVER > tep->ssl.state)
 766     {
 767         ret = mbedtls_ssl_handshake_step(&tep->ssl);
 768         if (MBEDTLS_ERR_SSL_CONN_EOF == ret)
 769         {
 770             break;
 771         }
 772         TLS_CHECK_HANDSHAKE_FAIL(tep, ret, "Handshake error", 0, NULL);
 773     }
 774     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 775     return tep;
 776 }
 777
 778 void CAdeinitTlsAdapter()
 779 {
 780     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
 781
 782     VERIFY_NON_NULL_VOID(g_caTlsContext, NET_TLS_TAG, "context is NULL");
 783     VERIFY_NON_NULL_VOID(g_tlsContextMutex, NET_TLS_TAG, "context mutex is NULL");
 784
 785     //Lock tlsContext mutex
 786     ca_mutex_lock(g_tlsContextMutex);
 787
 788     // Clear all lists
 789     deletePeerList();
 790
 791     // De-initialize mbedTLS
 792     mbedtls_x509_crt_free(&g_caTlsContext->crt);
 793     mbedtls_pk_free(&g_caTlsContext->pkey);
 794     mbedtls_ssl_config_free(&g_caTlsContext->clientConf);
 795     mbedtls_ssl_config_free(&g_caTlsContext->serverConf);
 796     mbedtls_ctr_drbg_free(&g_caTlsContext->rnd);
 797     mbedtls_entropy_free(&g_caTlsContext->entropy);
 798
 799     // De-initialize tls Context
 800     OICFree(g_caTlsContext);
 801     g_caTlsContext = NULL;
 802
 803     // Unlock tlsContext mutex and de-initialize it
 804     ca_mutex_unlock(g_tlsContextMutex);
 805     ca_mutex_free(g_tlsContextMutex);
 806     g_tlsContextMutex = NULL;
 807
 808     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s ", __func__);
 809 }
 810
 811 CAResult_t CAinitTlsAdapter()
 812 {
 813     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
 814
 815     // Initialize mutex for tlsContext
 816     if (NULL == g_tlsContextMutex)
 817     {
 818         g_tlsContextMutex = ca_mutex_new();
 819         VERIFY_NON_NULL_RET(g_tlsContextMutex, NET_TLS_TAG, "malloc failed",
 820                             CA_MEMORY_ALLOC_FAILED);
 821     }
 822     else
 823     {
 824         OIC_LOG(ERROR, NET_TLS_TAG, "CAAdapterNettlsInit done already!");
 825         return CA_STATUS_OK;
 826     }
 827
 828     // Lock tlsContext mutex and create tlsContext
 829     ca_mutex_lock(g_tlsContextMutex);
 830     g_caTlsContext = (TlsContext_t *)OICCalloc(1, sizeof(TlsContext_t));
 831
 832     if (NULL == g_caTlsContext)
 833     {
 834         OIC_LOG(ERROR, NET_TLS_TAG, "Context malloc failed");
 835         ca_mutex_unlock(g_tlsContextMutex);
 836         ca_mutex_free(g_tlsContextMutex);
 837         g_tlsContextMutex = NULL;
 838         return CA_MEMORY_ALLOC_FAILED;
 839     }
 840
 841     // Create peer list
 842     g_caTlsContext->peerList = u_arraylist_create();
 843
 844     if(NULL == g_caTlsContext->peerList)
 845     {
 846         OIC_LOG(ERROR, NET_TLS_TAG, "peerList initialization failed!");
 847         OICFree(g_caTlsContext);
 848         g_caTlsContext = NULL;
 849         ca_mutex_unlock(g_tlsContextMutex);
 850         ca_mutex_free(g_tlsContextMutex);
 851         g_tlsContextMutex = NULL;
 852         return CA_STATUS_FAILED;
 853     }
 854
 855     /* Initialize TLS library
 856      */
 857 #ifndef NDEBUG
 858     char version[MBED_TLS_VERSION_LEN];
 859     mbedtls_version_get_string(version);
 860     OIC_LOG_V(INFO, NET_TLS_TAG, "mbed TLS version: %s", version);
 861 #endif
 862
 863     /* Entropy settings
 864      */
 865     mbedtls_entropy_init(&g_caTlsContext->entropy);
 866     mbedtls_ctr_drbg_init(&g_caTlsContext->rnd);
 867
 868 #ifdef __unix__
 869     unsigned char seed[sizeof(SEED)] = {0};
 870     int urandomFd = -2;
 871     urandomFd = open("/dev/urandom", O_RDONLY);
 872     if(urandomFd == -1)
 873     {
 874         OIC_LOG(ERROR, NET_TLS_TAG, "Fails open /dev/urandom!");
 875         ca_mutex_unlock(g_tlsContextMutex);
 876         CAdeinitTlsAdapter();
 877         return CA_STATUS_FAILED;
 878     }
 879     if(0 > read(urandomFd, seed, sizeof(seed)))
 880     {
 881         OIC_LOG(ERROR, NET_TLS_TAG, "Fails read from /dev/urandom!");
 882         close(urandomFd);
 883         ca_mutex_unlock(g_tlsContextMutex);
 884         CAdeinitTlsAdapter();
 885         return CA_STATUS_FAILED;
 886     }
 887     close(urandomFd);
 888
 889 #else
 890     unsigned char * seed = (unsigned char*) SEED;
 891 #endif
 892     if(0 != mbedtls_ctr_drbg_seed(&g_caTlsContext->rnd, mbedtls_entropy_func,
 893                                   &g_caTlsContext->entropy, seed, sizeof(SEED)))
 894     {
 895         OIC_LOG(ERROR, NET_TLS_TAG, "Seed initialization failed!");
 896         ca_mutex_unlock(g_tlsContextMutex);
 897         CAdeinitTlsAdapter();
 898         return CA_STATUS_FAILED;
 899     }
 900     mbedtls_ctr_drbg_set_prediction_resistance(&g_caTlsContext->rnd, MBEDTLS_CTR_DRBG_PR_OFF);
 901
 902     /* Client SSL configuration
 903      */
 904     mbedtls_ssl_config_init(&g_caTlsContext->clientConf);
 905     if (mbedtls_ssl_config_defaults(&g_caTlsContext->clientConf, MBEDTLS_SSL_IS_CLIENT,
 906                                     MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT) != 0)
 907     {
 908         OIC_LOG(ERROR, NET_TLS_TAG, "Client config initialization failed!");
 909         ca_mutex_unlock(g_tlsContextMutex);
 910         CAdeinitTlsAdapter();
 911         return CA_STATUS_FAILED;
 912     }
 913
 914     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 915
 916     mbedtls_ssl_conf_psk_cb(&g_caTlsContext->clientConf, getTlsCredentialsCallback, NULL);
 917     mbedtls_ssl_conf_rng( &g_caTlsContext->clientConf, mbedtls_ctr_drbg_random,
 918                           &g_caTlsContext->rnd);
 919     mbedtls_ssl_conf_curves(&g_caTlsContext->clientConf, curve[ADAPTER_CURVE_SECP256R1]);
 920     mbedtls_ssl_conf_min_version(&g_caTlsContext->clientConf, MBEDTLS_SSL_MAJOR_VERSION_3,
 921                                  MBEDTLS_SSL_MINOR_VERSION_1);
 922     mbedtls_ssl_conf_renegotiation(&g_caTlsContext->clientConf, MBEDTLS_SSL_RENEGOTIATION_DISABLED);
 923
 924     mbedtls_ssl_conf_authmode(&g_caTlsContext->clientConf, MBEDTLS_SSL_VERIFY_REQUIRED);
 925 #ifndef NDEBUG
 926     mbedtls_ssl_conf_dbg( &g_caTlsContext->clientConf, debugTls, NULL);
 927 #endif
 928
 929     /* Server SSL configuration
 930      */
 931     mbedtls_ssl_config_init(&g_caTlsContext->serverConf);
 932     if (mbedtls_ssl_config_defaults(&g_caTlsContext->serverConf, MBEDTLS_SSL_IS_SERVER,
 933                                     MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT) != 0)
 934     {
 935         OIC_LOG(ERROR, NET_TLS_TAG, "Server config initialization failed!");
 936         ca_mutex_unlock(g_tlsContextMutex);
 937         CAdeinitTlsAdapter();
 938         return CA_STATUS_FAILED;
 939     }
 940
 941     mbedtls_ssl_conf_psk_cb(&g_caTlsContext->serverConf, getTlsCredentialsCallback, NULL);
 942     mbedtls_ssl_conf_rng( &g_caTlsContext->serverConf, mbedtls_ctr_drbg_random,
 943                           &g_caTlsContext->rnd);
 944     mbedtls_ssl_conf_curves(&g_caTlsContext->serverConf, curve[ADAPTER_CURVE_SECP256R1]);
 945     mbedtls_ssl_conf_min_version(&g_caTlsContext->serverConf, MBEDTLS_SSL_MAJOR_VERSION_3,
 946                                  MBEDTLS_SSL_MINOR_VERSION_1);
 947     mbedtls_ssl_conf_renegotiation(&g_caTlsContext->serverConf, MBEDTLS_SSL_RENEGOTIATION_DISABLED);
 948     mbedtls_ssl_conf_authmode(&g_caTlsContext->serverConf, MBEDTLS_SSL_VERIFY_REQUIRED);
 949
 950 #ifndef NDEBUG
 951     mbedtls_ssl_conf_dbg( &g_caTlsContext->serverConf, debugTls, NULL);
 952     mbedtls_debug_set_threshold(MBED_TLS_DEBUG_LEVEL);
 953 #endif
 954
 955     // set default cipher to PSK
 956     CAsetTlsCipherSuite(MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256);
 957
 958     // init X.509
 959     mbedtls_x509_crt_init(&g_caTlsContext->ca);
 960     mbedtls_x509_crt_init(&g_caTlsContext->crt);
 961     mbedtls_pk_init(&g_caTlsContext->pkey);
 962     mbedtls_x509_crl_init(&g_caTlsContext->crl);
 963
 964     ca_mutex_unlock(g_tlsContextMutex);
 965
 966     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 967     return CA_STATUS_OK;
 968 }
 969 /**
 970  * Creates cache message structure and fills with data.
 971  *
 972  * @param[in]  data    data array
 973  * @param[in]  dataLen    data array length
 974  *
 975  * @return  message or NULL
 976  */
 977 TlsCacheMessage_t *  newTlsCacheMessage(uint8_t * data, size_t dataLen)
 978 {
 979     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
 980     VERIFY_NON_NULL_RET(data, NET_TLS_TAG, "Param data is NULL" , NULL);
 981     if (0 == dataLen)
 982     {
 983         OIC_LOG(ERROR, NET_TLS_TAG, "dataLen is equal to zero");
 984         OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 985         return NULL;
 986     }
 987     TlsCacheMessage_t * message = (TlsCacheMessage_t *) OICCalloc(1, sizeof(TlsCacheMessage_t));
 988     if (NULL == message)
 989     {
 990         OIC_LOG(ERROR, NET_TLS_TAG, "calloc failed!");
 991         OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
 992         return NULL;
 993     }
 994
 995     message->data = (uint8_t *)OICCalloc(dataLen, sizeof(uint8_t));
 996     if (NULL == message->data)
 997     {
 998         OIC_LOG(ERROR, NET_TLS_TAG, "calloc failed!");
 999         OICFree(message);
1000         OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
1001         return NULL;
1002     }
1003     memcpy(message->data, data, dataLen);
1004     message->len = dataLen;
1005     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
1006     return message;
1007 }
1008
1009 /* Send data via TLS connection.
1010  */
1011 CAResult_t CAencryptTls(const CAEndpoint_t *endpoint,
1012                         void *data, uint32_t dataLen)
1013 {
1014     int ret = 0;
1015
1016     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s ", __func__);
1017
1018     VERIFY_NON_NULL_RET(endpoint, NET_TLS_TAG,"Remote address is NULL", CA_STATUS_INVALID_PARAM);
1019     VERIFY_NON_NULL_RET(data, NET_TLS_TAG, "Data is NULL", CA_STATUS_INVALID_PARAM);
1020
1021     if (0 == dataLen)
1022     {
1023         OIC_LOG_V(ERROR, NET_TLS_TAG, "dataLen is zero [%d]", dataLen);
1024         return CA_STATUS_FAILED;
1025     }
1026
1027     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Data to be encrypted dataLen [%d]", dataLen);
1028
1029     ca_mutex_lock(g_tlsContextMutex);
1030     if(NULL == g_caTlsContext)
1031     {
1032         OIC_LOG(ERROR, NET_TLS_TAG, "Context is NULL");
1033         ca_mutex_unlock(g_tlsContextMutex);
1034         return CA_STATUS_FAILED;
1035     }
1036
1037     TlsEndPoint_t * tep = getTlsPeer(endpoint);
1038     if (NULL == tep)
1039     {
1040         tep = initiateTlsHandshake(endpoint);
1041     }
1042     if (NULL == tep)
1043     {
1044         OIC_LOG(ERROR, NET_TLS_TAG, "TLS handshake failed");
1045         ca_mutex_unlock(g_tlsContextMutex);
1046         return CA_STATUS_FAILED;
1047     }
1048
1049     if (MBEDTLS_SSL_HANDSHAKE_OVER == tep->ssl.state)
1050     {
1051         ret = mbedtls_ssl_write(&tep->ssl, (unsigned char *) data, dataLen);
1052
1053         if(ret < 0)
1054         {
1055             OIC_LOG_V(ERROR, NET_TLS_TAG, "mbedTLS write returned %d", ret);
1056             if (g_tlsHandshakeCallback)
1057             {
1058                 CAErrorInfo_t errorInfo = {.result = CA_STATUS_FAILED};
1059                 g_tlsHandshakeCallback(&tep->sep.endpoint, &errorInfo);
1060             }
1061             removePeerFromList(&tep->sep.endpoint);
1062             ca_mutex_unlock(g_tlsContextMutex);
1063             return CA_STATUS_FAILED;
1064         }
1065     }
1066     else
1067     {
1068         TlsCacheMessage_t * msg = newTlsCacheMessage(data, dataLen);
1069         if (NULL == msg || !u_arraylist_add(tep->cacheList, (void *) msg))
1070         {
1071             OIC_LOG(ERROR, NET_TLS_TAG, "u_arraylist_add failed!");
1072             ca_mutex_unlock(g_tlsContextMutex);
1073             return CA_STATUS_FAILED;
1074         }
1075     }
1076
1077     ca_mutex_unlock(g_tlsContextMutex);
1078
1079     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
1080     return CA_STATUS_OK;
1081 }
1082 /**
1083  * Sends cached messages via TLS connection.
1084  *
1085  * @param[in]  tep    remote address with session info
1086  */
1087 static void sendCacheMessages(TlsEndPoint_t * tep)
1088 {
1089     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
1090     VERIFY_NON_NULL_VOID(tep, NET_TLS_TAG, "Param tep is NULL");
1091
1092     uint32_t listIndex = 0;
1093     uint32_t listLength = 0;
1094     listLength = u_arraylist_length(tep->cacheList);
1095     for (listIndex = 0; listIndex < listLength;)
1096     {
1097         int ret = 0;
1098         TlsCacheMessage_t * msg = (TlsCacheMessage_t *) u_arraylist_get(tep->cacheList, listIndex);
1099         if (NULL != msg && NULL != msg->data && 0 != msg->len)
1100         {
1101             do
1102             {
1103                 ret = mbedtls_ssl_write(&tep->ssl, (unsigned char *) msg->data, msg->len);
1104             }
1105             while(MBEDTLS_ERR_SSL_WANT_WRITE == ret);
1106
1107             if(ret < 0)
1108             {
1109                 OIC_LOG_V(ERROR, NET_TLS_TAG,"mbedTLS write returned %d", ret );
1110             }
1111             if (u_arraylist_remove(tep->cacheList, listIndex))
1112             {
1113                 deleteTlsCacheMessage(msg);
1114                 // Reduce list length by 1 as we removed one element.
1115                 listLength--;
1116             }
1117             else
1118             {
1119                 OIC_LOG(ERROR, NET_TLS_TAG, "u_arraylist_remove failed.");
1120                 break;
1121             }
1122         }
1123         else
1124         {
1125             // Move to the next element
1126             ++listIndex;
1127         }
1128     }
1129     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
1130 }
1131
1132 void CAsetTlsHandshakeCallback(CAErrorCallback tlsHandshakeCallback)
1133 {
1134     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
1135     g_tlsHandshakeCallback = tlsHandshakeCallback;
1136     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
1137 }
1138 // TODO move ConvertStrToUuid function to common module
1139 /*
1140  * Converts string UUID to CARemoteId_t
1141  *
1142  * @param strUuid Device UUID in string format
1143  * @param uuid converted UUID in CARemoteId_t format
1144  *
1145  * @return 0 for success.
1146  * */
1147 static int ConvertStrToUuid(const char* strUuid, CARemoteId_t* uuid)
1148 {
1149     if(NULL == strUuid || NULL == uuid)
1150     {
1151         OIC_LOG(ERROR, NET_TLS_TAG, "ConvertStrToUuid : Invalid param");
1152         return -1;
1153     }
1154
1155     size_t urnIdx = 0;
1156     size_t uuidIdx = 0;
1157     size_t strUuidLen = 0;
1158     char convertedUuid[UUID_LENGTH * 2] = {0};
1159
1160     strUuidLen = strlen(strUuid);
1161     if(0 == strUuidLen)
1162     {
1163         OIC_LOG(INFO, NET_TLS_TAG, "The empty string detected, The UUID will be converted to "\
1164                            "\"00000000-0000-0000-0000-000000000000\"");
1165     }
1166     else if(UUID_LENGTH * 2 + 4 == strUuidLen)
1167     {
1168         for(uuidIdx=0, urnIdx=0; uuidIdx < UUID_LENGTH ; uuidIdx++, urnIdx+=2)
1169         {
1170             if(*(strUuid + urnIdx) == '-')
1171             {
1172                 urnIdx++;
1173             }
1174             sscanf(strUuid + urnIdx, "%2hhx", &convertedUuid[uuidIdx]);
1175         }
1176     }
1177     else
1178     {
1179         OIC_LOG(ERROR, NET_TLS_TAG, "Invalid string uuid format");
1180         return -1;
1181     }
1182
1183     memcpy(uuid->id, convertedUuid, UUID_LENGTH);
1184     uuid->id_length = UUID_LENGTH;
1185     return 0;
1186 }
1187
1188 /* Read data from TLS connection
1189  */
1190 CAResult_t CAdecryptTls(const CASecureEndpoint_t *sep, uint8_t *data, uint32_t dataLen)
1191 {
1192     int ret = 0;
1193     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
1194     VERIFY_NON_NULL_RET(sep, NET_TLS_TAG, "endpoint is NULL" , CA_STATUS_INVALID_PARAM);
1195     VERIFY_NON_NULL_RET(data, NET_TLS_TAG, "Param data is NULL" , CA_STATUS_INVALID_PARAM);
1196
1197     ca_mutex_lock(g_tlsContextMutex);
1198     if (NULL == g_caTlsContext)
1199     {
1200         OIC_LOG(ERROR, NET_TLS_TAG, "Context is NULL");
1201         ca_mutex_unlock(g_tlsContextMutex);
1202         return CA_STATUS_FAILED;
1203     }
1204
1205     if (ADAPTER_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 == g_caTlsContext->cipher &&
1206             0 != initPskIdentity(&g_caTlsContext->serverConf))
1207     {
1208         ca_mutex_unlock(g_tlsContextMutex);
1209         return CA_STATUS_FAILED;
1210     }
1211
1212     TlsEndPoint_t * peer = getTlsPeer(&sep->endpoint);
1213     if (NULL == peer)
1214     {
1215         peer = newTlsEndPoint(&sep->endpoint, &g_caTlsContext->serverConf);
1216         if (NULL == peer)
1217         {
1218             OIC_LOG(ERROR, NET_TLS_TAG, "Malloc failed!");
1219             ca_mutex_unlock(g_tlsContextMutex);
1220             return CA_STATUS_FAILED;
1221         }
1222
1223         if (ADAPTER_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8 == g_caTlsContext->cipher ||
1224             ADAPTER_TLS_RSA_WITH_AES_256_CBC_SHA == g_caTlsContext->cipher)
1225         {
1226             ret = loadX509();
1227             if (0 != ret)
1228             {
1229                 OIC_LOG(ERROR, NET_TLS_TAG, "Failed to init X.509");
1230                 deleteTlsEndPoint(peer);
1231                 ca_mutex_unlock(g_tlsContextMutex);
1232                 return CA_STATUS_FAILED;
1233             }
1234         }
1235
1236         ret = u_arraylist_add(g_caTlsContext->peerList, (void *) peer);
1237         if (!ret)
1238         {
1239             OIC_LOG(ERROR, NET_TLS_TAG, "u_arraylist_add failed!");
1240             OICFree(peer);
1241             ca_mutex_unlock(g_tlsContextMutex);
1242             return CA_STATUS_FAILED;
1243         }
1244     }
1245     OIC_LOG_BUFFER(DEBUG, NET_TLS_TAG, data, dataLen);
1246     peer->recBuf.buff = data;
1247     peer->recBuf.len = dataLen;
1248     peer->recBuf.loaded = 0;
1249
1250     OIC_LOG(DEBUG, NET_TLS_TAG, "Call mbedTLS handshake steps");
1251
1252     while (MBEDTLS_SSL_HANDSHAKE_OVER > peer->ssl.state)
1253     {
1254         ret = mbedtls_ssl_handshake_step(&peer->ssl);
1255         if (MBEDTLS_ERR_SSL_CONN_EOF == ret)
1256         {
1257             break;
1258         }
1259         TLS_CHECK_HANDSHAKE_FAIL(peer, ret, "Handshake error", 1, CA_STATUS_FAILED);
1260         if (MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC == peer->ssl.state)
1261         {
1262             memcpy(peer->master, peer->ssl.session_negotiate->master, sizeof(peer->master));
1263         }
1264
1265         if (MBEDTLS_SSL_HANDSHAKE_OVER == peer->ssl.state)
1266         {
1267             if (MBEDTLS_SSL_IS_CLIENT == peer->ssl.conf->endpoint)
1268             {
1269                 sendCacheMessages(peer);
1270                 if (g_tlsHandshakeCallback)
1271                 {
1272                     CAErrorInfo_t errorInfo = {.result = CA_STATUS_OK};
1273                     g_tlsHandshakeCallback(&peer->sep.endpoint, &errorInfo);
1274                 }
1275             }
1276             else
1277             {
1278                 if (ADAPTER_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8 == g_caTlsContext->cipher)
1279                 {
1280                     char uuid[UUID_LENGTH * 2 + 5] = {0};
1281                     void * uuidPos = NULL;
1282                     void * userIdPos = NULL;
1283                     const mbedtls_x509_crt * peerCert = mbedtls_ssl_get_peer_cert(&peer->ssl);
1284                     ret = (NULL == peerCert ? -1 : 0);
1285                     TLS_CHECK_HANDSHAKE_FAIL(peer, ret, "Failed to retrieve subject",
1286                                                                                1, CA_STATUS_FAILED);
1287                     ret = mbedtls_ssl_get_verify_result(&peer->ssl);
1288                     TLS_CHECK_HANDSHAKE_FAIL(peer, ret, "Failed to retrieve subject",
1289                                                                                1, CA_STATUS_FAILED);
1290                     uuidPos = memmem((void *) peerCert->subject_raw.p, peerCert->subject_raw.len,
1291                                                      (void *) UUID_PREFIX, sizeof(UUID_PREFIX) - 1);
1292
1293                     ret = (NULL == uuidPos ? -1 : 0);
1294                     TLS_CHECK_HANDSHAKE_FAIL(peer, ret, "Failed to retrieve subject",
1295                                                                                1, CA_STATUS_FAILED);
1296
1297                     memcpy(uuid, uuidPos + sizeof(UUID_PREFIX) - 1, UUID_LENGTH * 2 + 4);
1298                     ret = ConvertStrToUuid(uuid, &peer->sep.identity);
1299                     TLS_CHECK_HANDSHAKE_FAIL(peer, ret, "Failed to convert subject",
1300                                                                                1, CA_STATUS_FAILED);
1301
1302                     userIdPos = memmem((void *) peerCert->subject_raw.p, peerCert->subject_raw.len,
1303                                                  (void *) USERID_PREFIX, sizeof(USERID_PREFIX) - 1);
1304                     if (NULL != userIdPos)
1305                     {
1306                         memcpy(uuid, userIdPos + sizeof(USERID_PREFIX) - 1, UUID_LENGTH * 2 + 4);
1307                         ret = ConvertStrToUuid(uuid, &peer->sep.userId);
1308                         TLS_CHECK_HANDSHAKE_FAIL(peer, ret,
1309                                  "Failed to convert subject alternative name", 1, CA_STATUS_FAILED);
1310                     }
1311                     else
1312                     {
1313                         OIC_LOG(DEBUG, NET_TLS_TAG, "Subject alternative name not found");
1314                     }
1315                 }
1316             }
1317             ca_mutex_unlock(g_tlsContextMutex);
1318             OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
1319             return CA_STATUS_OK;
1320         }
1321     }
1322
1323     if (MBEDTLS_SSL_HANDSHAKE_OVER == peer->ssl.state)
1324     {
1325         uint8_t decryptBuffer[TLS_MSG_BUF_LEN] = {0};
1326         do
1327         {
1328             ret = mbedtls_ssl_read(&peer->ssl, decryptBuffer, TLS_MSG_BUF_LEN);
1329         } while (MBEDTLS_ERR_SSL_WANT_READ == ret);
1330         if (MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY == ret)
1331         {
1332             OIC_LOG(INFO, NET_TLS_TAG, "Connection was closed gracefully");
1333             removePeerFromList(&peer->sep.endpoint);
1334             ca_mutex_unlock(g_tlsContextMutex);
1335             return CA_STATUS_OK;
1336         }
1337
1338         if (0 >= ret)
1339         {
1340             OIC_LOG_V(ERROR, NET_TLS_TAG, "mbedtls_ssl_read returned -0x%x", -ret);
1341             if (g_tlsHandshakeCallback)
1342             {
1343                 CAErrorInfo_t errorInfo = {.result = CA_STATUS_FAILED};
1344                 g_tlsHandshakeCallback(&peer->sep.endpoint, &errorInfo);
1345             }
1346             removePeerFromList(&peer->sep.endpoint);
1347             ca_mutex_unlock(g_tlsContextMutex);
1348             return CA_STATUS_FAILED;
1349         }
1350
1351         g_caTlsContext->adapterCallbacks[0].recvCallback(&peer->sep, decryptBuffer, ret);
1352     }
1353
1354     ca_mutex_unlock(g_tlsContextMutex);
1355     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
1356     return CA_STATUS_OK;
1357 }
1358
1359 void CAsetTlsAdapterCallbacks(CAPacketReceivedCallback recvCallback,
1360                               CAPacketSendCallback sendCallback,
1361                               CATransportAdapter_t type)
1362 {
1363     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
1364     VERIFY_NON_NULL_VOID(sendCallback, NET_TLS_TAG, "sendCallback is NULL");
1365     VERIFY_NON_NULL_VOID(recvCallback, NET_TLS_TAG, "recvCallback is NULL");
1366     ca_mutex_lock(g_tlsContextMutex);
1367     if (NULL == g_caTlsContext)
1368     {
1369         OIC_LOG(ERROR, NET_TLS_TAG, "Context is NULL");
1370         ca_mutex_unlock(g_tlsContextMutex);
1371         return;
1372     }
1373
1374     if (MAX_SUPPORTED_ADAPTERS > type)
1375     {
1376         // TODO: change the zeros to better values.
1377         g_caTlsContext->adapterCallbacks[0].recvCallback = recvCallback;
1378         g_caTlsContext->adapterCallbacks[0].sendCallback = sendCallback;
1379     }
1380
1381     ca_mutex_unlock(g_tlsContextMutex);
1382     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
1383 }
1384
1385 CAResult_t CAsetTlsCipherSuite(const uint32_t cipher)
1386 {
1387     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
1388     switch(cipher)
1389     {
1390         case MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA:
1391         {
1392             mbedtls_ssl_conf_ciphersuites(&g_caTlsContext->clientConf,
1393                                          tlsCipher[ADAPTER_TLS_RSA_WITH_AES_256_CBC_SHA]);
1394             mbedtls_ssl_conf_ciphersuites(&g_caTlsContext->serverConf,
1395                                          tlsCipher[ADAPTER_TLS_RSA_WITH_AES_256_CBC_SHA]);
1396             g_caTlsContext->cipher = ADAPTER_TLS_RSA_WITH_AES_256_CBC_SHA;
1397             break;
1398         }
1399         case MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8:
1400         {
1401             mbedtls_ssl_conf_ciphersuites(&g_caTlsContext->clientConf,
1402                                          tlsCipher[ADAPTER_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8]);
1403             mbedtls_ssl_conf_ciphersuites(&g_caTlsContext->serverConf,
1404                                          tlsCipher[ADAPTER_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8]);
1405             g_caTlsContext->cipher = ADAPTER_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8;
1406             break;
1407         }
1408         case MBEDTLS_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA256:
1409         {
1410             mbedtls_ssl_conf_ciphersuites(&g_caTlsContext->clientConf,
1411                                          tlsCipher[ADAPTER_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA_256]);
1412             mbedtls_ssl_conf_ciphersuites(&g_caTlsContext->serverConf,
1413                                          tlsCipher[ADAPTER_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA_256]);
1414             g_caTlsContext->cipher = ADAPTER_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA_256;
1415             break;
1416         }
1417         case MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256:
1418         {
1419             mbedtls_ssl_conf_ciphersuites(&g_caTlsContext->clientConf,
1420                                           tlsCipher[ADAPTER_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256]);
1421             mbedtls_ssl_conf_ciphersuites(&g_caTlsContext->serverConf,
1422                                           tlsCipher[ADAPTER_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256]);
1423             g_caTlsContext->cipher = ADAPTER_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256;
1424             break;
1425         }
1426         default:
1427         {
1428             OIC_LOG(ERROR, NET_TLS_TAG, "Unknown cipher");
1429             return CA_STATUS_FAILED;
1430         }
1431     }
1432     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Selected cipher: 0x%x", cipher);
1433     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
1434     return CA_STATUS_OK;
1435 }
1436
1437 CAResult_t CAinitiateTlsHandshake(const CAEndpoint_t *endpoint)
1438 {
1439     CAResult_t res = CA_STATUS_OK;
1440     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
1441     VERIFY_NON_NULL_RET(endpoint, NET_TLS_TAG, "Param endpoint is NULL" , CA_STATUS_INVALID_PARAM);
1442     ca_mutex_lock(g_tlsContextMutex);
1443     if (NULL == initiateTlsHandshake(endpoint))
1444     {
1445         OIC_LOG(ERROR, NET_TLS_TAG, "TLS handshake failed");
1446         res = CA_STATUS_FAILED;
1447     }
1448     ca_mutex_unlock(g_tlsContextMutex);
1449     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
1450     return res;
1451 }
1452
1453 CAResult_t CAtlsGenerateOwnerPSK(const CAEndpoint_t *endpoint,
1454                                  uint8_t* ownerPSK, const size_t ownerPSKSize,
1455                                  const uint8_t* deviceID, const size_t deviceIDLen)
1456 {
1457     OIC_LOG_V(DEBUG, NET_TLS_TAG, "In %s", __func__);
1458
1459     VERIFY_NON_NULL_RET(ownerPSK, NET_TLS_TAG, "ownerPSK is NULL", CA_STATUS_INVALID_PARAM);
1460     VERIFY_NON_NULL_RET(deviceID, NET_TLS_TAG, "rsrcID is NULL", CA_STATUS_INVALID_PARAM);
1461
1462     ca_mutex_lock(g_tlsContextMutex);
1463     if (NULL == g_caTlsContext)
1464     {
1465         OIC_LOG(ERROR, NET_TLS_TAG, "Context is NULL");
1466         ca_mutex_unlock(g_tlsContextMutex);
1467         OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
1468         return CA_STATUS_FAILED;
1469     }
1470     TlsEndPoint_t * tep = getTlsPeer(endpoint);
1471     if (NULL == tep)
1472     {
1473         OIC_LOG(ERROR, NET_TLS_TAG, "Session does not exist");
1474         ca_mutex_unlock(g_tlsContextMutex);
1475         return CA_STATUS_FAILED;
1476     }
1477
1478     if (0 != mbedtls_pkcs12_derivation(ownerPSK, ownerPSKSize,
1479                                        tep->master, sizeof(tep->master),
1480                                        deviceID, deviceIDLen,
1481                                        MBEDTLS_MD_SHA1, MBEDTLS_PKCS12_DERIVE_KEY, 1))
1482     {
1483         OIC_LOG(ERROR, NET_TLS_TAG, "Failed to generate key");
1484         ca_mutex_unlock(g_tlsContextMutex);
1485         OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
1486         return CA_STATUS_FAILED;
1487     }
1488     OIC_LOG_V(DEBUG, NET_TLS_TAG, "PSK: ");
1489     OIC_LOG_BUFFER(DEBUG, NET_TLS_TAG, tep->master, sizeof(tep->master));
1490     ca_mutex_unlock(g_tlsContextMutex);
1491
1492     OIC_LOG_V(DEBUG, NET_TLS_TAG, "Out %s", __func__);
1493     return CA_STATUS_OK;
1494 }