resource/csdk/connectivity/src/adapter_util/ca_adapter_net_ssl.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 <stdbool.h>
  25 #include "ca_adapter_net_ssl.h"
  26 #include "cacommon.h"
  27 #include "caipinterface.h"
  28 #include "oic_malloc.h"
  29 #include "byte_array.h"
  30 #include "camutex.h"
  31
  32 // headers required for mbed TLS
  33 #include "mbedtls/platform.h"
  34 #include "mbedtls/ssl.h"
  35 #include "mbedtls/entropy.h"
  36 #include "mbedtls/ctr_drbg.h"
  37 #include "mbedtls/pkcs12.h"
  38 #include "mbedtls/ssl_internal.h"
  39 #ifdef __WITH_DTLS__
  40 #include "mbedtls/timing.h"
  41 #include "mbedtls/ssl_cookie.h"
  42 #endif
  43
  44 #ifndef NDEBUG
  45 #include "mbedtls/debug.h"
  46 #include "mbedtls/version.h"
  47 #endif
  48
  49 #ifdef __unix__
  50 #include <sys/types.h>
  51 #include <sys/stat.h>
  52 #include <fcntl.h>
  53 #include <unistd.h>
  54 #endif
  55
  56
  57 /**
  58  * @def MBED_TLS_VERSION_LEN
  59  * @brief mbedTLS version string length
  60  */
  61 #define MBED_TLS_VERSION_LEN (16)
  62 /**
  63  * @def SEED
  64  * @brief Seed for initialization RNG
  65  */
  66 #define SEED "IOTIVITY_RND"
  67 /**
  68  * @def UUID_PREFIX
  69  * @brief uuid prefix in certificate subject field
  70  */
  71 #define UUID_PREFIX "uuid:"
  72 /**
  73  * @def USERID_PREFIX
  74  * @brief userid prefix in certificate alternative subject name field
  75  */
  76 #define USERID_PREFIX "userid:"
  77
  78 /**
  79  * @def NET_SSL_TAG
  80  * @brief Logging tag for module name
  81  */
  82 #define NET_SSL_TAG "OIC_CA_NET_SSL"
  83 /**
  84  * @def MBED_TLS_TAG
  85  * @brief Logging tag for mbedTLS library
  86  */
  87 #define MBED_TLS_TAG "MBED_TLS"
  88 /**
  89  * @def MMBED_TLS_DEBUG_LEVEL
  90  * @brief Logging level for mbedTLS library
  91  */
  92 #define MBED_TLS_DEBUG_LEVEL (4)
  93
  94 /**
  95  * @def TLS_MSG_BUF_LEN
  96  * @brief Buffer size for TLS record. A single TLS record may be up to 16384 octets in length
  97  */
  98
  99 #define TLS_MSG_BUF_LEN (16384)
 100 /**
 101  * @def PSK_LENGTH
 102  * @brief PSK keys max length
 103  */
 104 #define PSK_LENGTH (256/8)
 105 /**
 106  * @def UUID_LENGTHPSK_LENGTH
 107  * @brief Identity max length
 108  */
 109 #define UUID_LENGTH (128/8)
 110 /**
 111  * @def MASTER_SECRET_LEN
 112  * @brief TLS master secret length
 113  */
 114 #define MASTER_SECRET_LEN (48)
 115 /**
 116  * @def RANDOM_LEN
 117  * @brief TLS client and server random bytes length
 118  */
 119 #define RANDOM_LEN (32)
 120 /**
 121  * @def RANDOM_LEN
 122  * @brief PSK generated keyblock length
 123  */
 124 #define KEY_BLOCK_LEN (96)
 125
 126 /**@def SSL_CLOSE_NOTIFY(peer, ret)
 127  *
 128  * Notifies of existing \a peer about closing TLS connection.
 129  *
 130  * @param[in] peer remote peer
 131  * @param[in] ret used internaly
 132  */
 133 #define SSL_CLOSE_NOTIFY(peer, ret)                                                                \
 134 do                                                                                                 \
 135 {                                                                                                  \
 136     (ret) = mbedtls_ssl_close_notify(&(peer)->ssl);                                                \
 137 } while (MBEDTLS_ERR_SSL_WANT_WRITE == (ret))
 138
 139 /**@def SSL_RES(peer, status)
 140  *
 141  * Sets SSL result for callback.
 142  *
 143  * @param[in] peer remote peer
 144  */
 145 #define SSL_RES(peer, status)                                                                      \
 146 if (g_sslCallback)                                                                                 \
 147 {                                                                                                  \
 148     CAErrorInfo_t errorInfo;                                                                       \
 149     errorInfo.result = (status);                                                                   \
 150     g_sslCallback(&(peer)->sep.endpoint, &errorInfo);                                              \
 151 }
 152 /**@def SSL_CHECK_FAIL(peer, ret, str, mutex, error, msg)
 153  *
 154  * Checks handshake result and send alert if needed.
 155  *
 156  * @param[in] peer remote peer
 157  * @param[in] ret error code
 158  * @param[in] str debug string
 159  * @param[in] mutex ca mutex
 160  * @param[in] return error code
 161  * @param[in] msg allert message
 162  */
 163 #define SSL_CHECK_FAIL(peer, ret, str, mutex, error, msg)                                          \
 164 if (0 != (ret) && MBEDTLS_ERR_SSL_WANT_READ != (int) (ret) &&                                      \
 165     MBEDTLS_ERR_SSL_WANT_WRITE != (int) (ret) &&                                                   \
 166     MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED != (int) (ret) &&                                        \
 167     MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY != (int) (ret))                                              \
 168 {                                                                                                  \
 169     OIC_LOG_V(ERROR, NET_SSL_TAG, "%s: -0x%x", (str), -(ret));                                     \
 170     if ((int) MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE != (int) (ret) &&                                \
 171        (int) MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO != (int) (ret))                                   \
 172     {                                                                                              \
 173         mbedtls_ssl_send_alert_message(&(peer)->ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL, (msg));        \
 174     }                                                                                              \
 175     SSL_RES((peer), CA_STATUS_FAILED);                                                             \
 176     RemovePeerFromList(&(peer)->sep.endpoint);                                                     \
 177     if (mutex)                                                                                     \
 178     {                                                                                              \
 179         ca_mutex_unlock(g_sslContextMutex);                                                        \
 180     }                                                                                              \
 181     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);                                             \
 182     return (error);                                                                                \
 183 }
 184 /** @def CHECK_MBEDTLS_RET(f, ...)
 185  * A macro that checks \a f function return code
 186  *
 187  * If function returns error code it goes to error processing.
 188  *
 189  * @param[in] f  Function to call
 190  */
 191 #define CHECK_MBEDTLS_RET(f, ...) do {                                                             \
 192 int ret = (f)(__VA_ARGS__);                                                                        \
 193 if (0 != ret) {                                                                                    \
 194     OIC_LOG_V(ERROR, NET_SSL_TAG, "%s returned -0x%04x\n", __func__, -(ret));                      \
 195     goto exit;                                                                                     \
 196 } } while(0)
 197
 198 typedef enum
 199 {
 200     ADAPTER_TLS_RSA_WITH_AES_256_CBC_SHA,
 201     ADAPTER_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8,
 202     ADAPTER_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA_256,
 203     ADAPTER_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
 204     ADAPTER_CIPHER_MAX
 205 } AdapterCipher_t;
 206
 207 typedef enum
 208 {
 209     ADAPTER_CURVE_SECP256R1,
 210     ADAPTER_CURVE_MAX
 211 } AdapterCurve_t;
 212
 213 int tlsCipher[ADAPTER_CIPHER_MAX][2] =
 214 {
 215     {MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA, 0},
 216     {MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8, 0},
 217     {MBEDTLS_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA256, 0},
 218     {MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256, 0}
 219 };
 220
 221 static int g_cipherSuitesList[ADAPTER_CIPHER_MAX];
 222
 223 mbedtls_ecp_group_id curve[ADAPTER_CURVE_MAX][2] =
 224 {
 225     {MBEDTLS_ECP_DP_SECP256R1, MBEDTLS_ECP_DP_NONE}
 226 };
 227
 228 static PkiInfo_t g_pkiInfo = {{NULL, 0}, {NULL, 0}, {NULL, 0}, {NULL, 0}};
 229
 230 typedef struct  {
 231     int code;
 232     int alert;
 233 } CrtVerifyAlert_t;
 234
 235 static const CrtVerifyAlert_t crtVerifyAlerts[] = {
 236     {MBEDTLS_X509_BADCERT_EXPIRED,       MBEDTLS_SSL_ALERT_MSG_CERT_EXPIRED},
 237     {MBEDTLS_X509_BADCERT_REVOKED,       MBEDTLS_SSL_ALERT_MSG_CERT_REVOKED},
 238     {MBEDTLS_X509_BADCERT_CN_MISMATCH,   MBEDTLS_SSL_ALERT_MSG_CERT_UNKNOWN},
 239     {MBEDTLS_X509_BADCERT_NOT_TRUSTED,   MBEDTLS_SSL_ALERT_MSG_UNKNOWN_CA},
 240     {MBEDTLS_X509_BADCRL_NOT_TRUSTED,    MBEDTLS_SSL_ALERT_MSG_UNKNOWN_CA},
 241     {MBEDTLS_X509_BADCRL_EXPIRED,        MBEDTLS_SSL_ALERT_MSG_INSUFFICIENT_SECURITY},
 242     {MBEDTLS_X509_BADCERT_MISSING,       MBEDTLS_SSL_ALERT_MSG_NO_CERT},
 243     {MBEDTLS_X509_BADCERT_SKIP_VERIFY,   MBEDTLS_SSL_ALERT_MSG_INSUFFICIENT_SECURITY},
 244     {MBEDTLS_X509_BADCERT_OTHER,         MBEDTLS_SSL_ALERT_MSG_INTERNAL_ERROR},
 245     {MBEDTLS_X509_BADCERT_FUTURE,        MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 246     {MBEDTLS_X509_BADCRL_FUTURE,         MBEDTLS_SSL_ALERT_MSG_INSUFFICIENT_SECURITY},
 247     {MBEDTLS_X509_BADCERT_KEY_USAGE,     MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 248     {MBEDTLS_X509_BADCERT_EXT_KEY_USAGE, MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 249     {MBEDTLS_X509_BADCERT_NS_CERT_TYPE,  MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 250     {MBEDTLS_X509_BADCERT_BAD_MD,        MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 251     {MBEDTLS_X509_BADCERT_BAD_PK,        MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 252     {MBEDTLS_X509_BADCERT_BAD_KEY,       MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 253     {MBEDTLS_X509_BADCRL_BAD_MD,         MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 254     {MBEDTLS_X509_BADCRL_BAD_PK,         MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 255     {MBEDTLS_X509_BADCRL_BAD_KEY,        MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 256     {0, 0}
 257 };
 258
 259 static int GetAlertCode(uint32_t flags)
 260 {
 261     const CrtVerifyAlert_t *cur;
 262
 263     for (cur = crtVerifyAlerts; cur->alert != 0 ; cur++)
 264     {
 265         if (flags & cur->code)
 266         {
 267             return cur->alert;
 268         }
 269     }
 270     return 0;
 271 }
 272
 273 #ifndef NDEBUG
 274 /**
 275  * Pass a message to the OIC logger.
 276  *
 277  * @param[in] ctx  opaque context for the callback
 278  * @param[in] level  debug level
 279  * @param[in] file  file name
 280  * @param[in] line  line number
 281  * @param[in] str  message
 282  */
 283 static void DebugSsl(void *ctx, int level, const char *file, int line, const char *str)
 284 {
 285     ((void) level);
 286     ((void) file);
 287     ((void) line);
 288     ((void) ctx);
 289
 290     OIC_LOG_V(DEBUG, MBED_TLS_TAG, "%s", str);
 291 }
 292 #endif
 293
 294 #if defined(_WIN32)
 295 /*
 296  * Finds the first occurrence of the byte string s in byte string l.
 297  */
 298
 299 static void * memmem(const void *l, size_t lLen, const void *s, size_t sLen)
 300 {
 301     char *cur;
 302     char *last;
 303     const char *cl = (const char *)l;
 304     const char *cs = (const char *)s;
 305
 306     if (lLen == 0 || sLen == 0)
 307     {
 308         return NULL;
 309     }
 310     if (lLen < sLen)
 311     {
 312         return NULL;
 313     }
 314     if (sLen == 1)
 315     {
 316         return (void *)memchr(l, (int)*cs, lLen);
 317     }
 318
 319     last = (char *)cl + lLen - sLen;
 320
 321     for (cur = (char *)cl; cur <= last; cur++)
 322     {
 323         if (cur[0] == cs[0] && memcmp(cur, cs, sLen) == 0)
 324         {
 325             return cur;
 326         }
 327     }
 328     return NULL;
 329 }
 330 #endif
 331 /**
 332  * structure to holds the information of cache message and address info.
 333  */
 334 typedef ByteArray_t SslCacheMessage_t;
 335
 336
 337 /**
 338  * Data structure for holding the send and recv callbacks.
 339  */
 340 typedef struct TlsCallBacks
 341 {
 342     CAPacketReceivedCallback recvCallback;  /**< Callback used to send data to upper layer. */
 343     CAPacketSendCallback sendCallback;      /**< Callback used to send data to socket layer. */
 344 } SslCallbacks_t;
 345
 346 /**
 347  * Data structure for holding the mbedTLS interface related info.
 348  */
 349 typedef struct SslContext
 350 {
 351     u_arraylist_t *peerList;         /**< peer list which holds the mapping between
 352                                               peer id, it's n/w address and mbedTLS context. */
 353     mbedtls_entropy_context entropy;
 354     mbedtls_ctr_drbg_context rnd;
 355     mbedtls_x509_crt ca;
 356     mbedtls_x509_crt crt;
 357     mbedtls_pk_context pkey;
 358
 359     mbedtls_ssl_config clientTlsConf;
 360     mbedtls_ssl_config serverTlsConf;
 361     mbedtls_ssl_config clientDtlsConf;
 362     mbedtls_ssl_config serverDtlsConf;
 363 #ifdef __WITH_DTLS__
 364     mbedtls_ssl_cookie_ctx cookie_ctx;
 365     mbedtls_timing_delay_context timer;
 366 #endif // __WITH_DTLS__
 367     AdapterCipher_t cipher;
 368     SslCallbacks_t adapterCallbacks[MAX_SUPPORTED_ADAPTERS];
 369     mbedtls_x509_crl crl;
 370     bool cipherFlag[2];
 371     int selectedCipher;
 372
 373 } SslContext_t;
 374
 375 /**
 376  * @var g_caSslContext
 377  * @brief global context which holds tls context and cache list information.
 378  */
 379 static SslContext_t * g_caSslContext = NULL;
 380
 381 /**
 382  * @var g_getCredentialsCallback
 383  * @brief callback to get TLS credentials (same as for DTLS)
 384  */
 385 static CAgetPskCredentialsHandler g_getCredentialsCallback = NULL;
 386 /**
 387  * @var g_getCerdentilTypesCallback
 388  * @brief callback to get different credential types from SRM
 389  */
 390 static CAgetCredentialTypesHandler g_getCredentialTypesCallback = NULL;
 391 /**
 392  * @var g_getPkixInfoCallback
 393  *
 394  * @brief callback to get X.509-based Public Key Infrastructure
 395  */
 396 static CAgetPkixInfoHandler g_getPkixInfoCallback = NULL;
 397
 398 /**
 399  * @var g_dtlsContextMutex
 400  * @brief Mutex to synchronize access to g_caSslContext.
 401  */
 402 static ca_mutex g_sslContextMutex = NULL;
 403
 404 /**
 405  * @var g_sslCallback
 406  * @brief callback to deliver the TLS handshake result
 407  */
 408 static CAErrorCallback g_sslCallback = NULL;
 409
 410 /**
 411  * Data structure for holding the data to be received.
 412  */
 413 typedef struct SslRecBuf
 414 {
 415     uint8_t * buff;
 416     size_t len;
 417     size_t loaded;
 418 } SslRecBuf_t;
 419 /**
 420  * Data structure for holding the data related to endpoint
 421  * and TLS session.
 422  */
 423 typedef struct SslEndPoint
 424 {
 425     mbedtls_ssl_context ssl;
 426     CASecureEndpoint_t sep;
 427     u_arraylist_t * cacheList;
 428     SslRecBuf_t recBuf;
 429     uint8_t master[MASTER_SECRET_LEN];
 430     uint8_t random[2*RANDOM_LEN];
 431 #ifdef __WITH_DTLS__
 432     mbedtls_ssl_cookie_ctx cookieCtx;
 433 #endif
 434
 435 } SslEndPoint_t;
 436
 437 void CAsetPskCredentialsCallback(CAgetPskCredentialsHandler credCallback)
 438 {
 439     // TODO Does this method needs protection of tlsContextMutex?
 440     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 441     g_getCredentialsCallback = credCallback;
 442     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 443 }
 444
 445 void CAsetPkixInfoCallback(CAgetPkixInfoHandler infoCallback)
 446 {
 447     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 448     g_getPkixInfoCallback = infoCallback;
 449     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 450 }
 451 void CAsetCredentialTypesCallback(CAgetCredentialTypesHandler credTypesCallback)
 452 {
 453     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 454     g_getCredentialTypesCallback = credTypesCallback;
 455     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 456 }
 457
 458 static int GetAdapterIndex(CATransportAdapter_t adapter)
 459 {
 460     switch (adapter)
 461     {
 462         case CA_ADAPTER_IP:
 463             return 0;
 464         case CA_ADAPTER_TCP:
 465             return 1;
 466         default:
 467             OIC_LOG(ERROR, NET_SSL_TAG, "Unsupported adapter");
 468             return -1;
 469     }
 470 }
 471 /**
 472  * Write callback.
 473  *
 474  * @param[in]  tep    TLS endpoint
 475  * @param[in]  data    message
 476  * @param[in]  dataLen    message length
 477  *
 478  * @return  message length
 479  */
 480 static int SendCallBack(void * tep, const unsigned char * data, size_t dataLen)
 481 {
 482     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 483     VERIFY_NON_NULL_RET(tep, NET_SSL_TAG, "secure endpoint is NULL", 0);
 484     VERIFY_NON_NULL_RET(data, NET_SSL_TAG, "data is NULL", 0);
 485     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Data len: %zu", dataLen);
 486     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Adapter: %u", ((SslEndPoint_t * )tep)->sep.endpoint.adapter);
 487     int adapterIndex = GetAdapterIndex(((SslEndPoint_t * )tep)->sep.endpoint.adapter);
 488     if (0 == adapterIndex || 1 == adapterIndex)
 489     {
 490         CAPacketSendCallback sendCallback = g_caSslContext->adapterCallbacks[adapterIndex].sendCallback;
 491         sendCallback(&(((SslEndPoint_t * )tep)->sep.endpoint), (const void *) data, (uint32_t) dataLen);
 492     }
 493     else
 494     {
 495         OIC_LOG(ERROR, NET_SSL_TAG, "Unsupported adapter");
 496         dataLen = 0;
 497     }
 498
 499     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 500     return dataLen;
 501 }
 502 /**
 503  * Read callback.
 504  *
 505  * @param[in]  tep    TLS endpoint
 506  * @param[in]  data    message
 507  * @param[in]  dataLen    message length
 508  *
 509  * @return  read length
 510  */
 511 static int RecvCallBack(void * tep, unsigned char * data, size_t dataLen)
 512 {
 513     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 514     VERIFY_NON_NULL_RET(tep, NET_SSL_TAG, "endpoint is NULL", 0);
 515     VERIFY_NON_NULL_RET(data, NET_SSL_TAG, "data is NULL", 0);
 516
 517     SslRecBuf_t *recBuf = &((SslEndPoint_t *)tep)->recBuf;
 518     size_t retLen = (recBuf->len > recBuf->loaded ? recBuf->len - recBuf->loaded : 0);
 519     retLen = (retLen < dataLen ? retLen : dataLen);
 520
 521     memcpy(data, recBuf->buff + recBuf->loaded, retLen);
 522     recBuf->loaded += retLen;
 523
 524     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 525     return (int)retLen;
 526 }
 527
 528 /**
 529  * Parse chain of X.509 certificates.
 530  *
 531  * @param[out] crt     container for X.509 certificates
 532  * @param[in]  data    buffer with X.509 certificates. Certificates may be in either in PEM
 533                        or DER format in a jumble. Each PEM certificate must be NULL-terminated.
 534  * @param[in]  bufLen  buffer length
 535  *
 536  * @return  0 on success, -1 on error
 537  */
 538 static int ParseChain(mbedtls_x509_crt * crt, const unsigned char * buf, int bufLen)
 539 {
 540     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 541     VERIFY_NON_NULL_RET(crt, NET_SSL_TAG, "Param crt is NULL" , -1);
 542     VERIFY_NON_NULL_RET(buf, NET_SSL_TAG, "Param buf is NULL" , -1);
 543
 544     int pos = 0;
 545     int ret = 0;
 546     size_t len = 0;
 547     unsigned char * tmp = NULL;
 548
 549     char pemCertHeader[] = {
 550         0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x43, 0x45, 0x52,
 551         0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d
 552     };
 553     char pemCertFooter[] = {
 554         0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x45, 0x4e, 0x44, 0x20, 0x43, 0x45, 0x52, 0x54, 0x49,
 555         0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d
 556     };
 557     size_t pemCertHeaderLen = sizeof(pemCertHeader);
 558     size_t pemCertFooterLen = sizeof(pemCertFooter);
 559
 560     while (pos < bufLen)
 561     {
 562         if (buf[pos] == 0x30 && buf[pos + 1] == 0x82)
 563         {
 564             tmp = (unsigned char *)buf + pos + 1;
 565             CHECK_MBEDTLS_RET(mbedtls_asn1_get_len, &tmp, buf + bufLen, &len);
 566             if (pos + len < bufLen)
 567             {
 568                 CHECK_MBEDTLS_RET(mbedtls_x509_crt_parse_der, crt, buf + pos, len + 4);
 569             }
 570             pos += len + 4;
 571         }
 572         else if (0 == memcmp(buf + pos, pemCertHeader, pemCertHeaderLen))
 573         {
 574             void * endPos = NULL;
 575             endPos = memmem(&(buf[pos]), bufLen - pos, pemCertFooter, pemCertFooterLen);
 576             if (NULL == endPos)
 577             {
 578                 OIC_LOG(ERROR, NET_SSL_TAG, "Error: end of PEM certificate not found.");
 579                 OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 580                 return -1;
 581             }
 582             if ((*((char*)endPos + pemCertFooterLen + 0) == 0x0d) &&
 583                 (*((char*)endPos + pemCertFooterLen + 1) == 0x0a) &&
 584                 (*((char*)endPos + pemCertFooterLen + 2) == 0x00))
 585             {
 586                 len = (char*)endPos - ((char*)buf + pos) + pemCertFooterLen + 3;
 587             }
 588             else if ((*((char*)endPos + pemCertFooterLen + 0) == 0x0a) &&
 589                      (*((char*)endPos + pemCertFooterLen + 1) == 0x00))
 590             {
 591                 len = (char*)endPos - ((char*)buf + pos) + pemCertFooterLen + 2;
 592             }
 593             else
 594             {
 595                 OIC_LOG_V(ERROR, NET_SSL_TAG, "Incorrect PEM certificate ending");
 596                 OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 597                 return -1;
 598             }
 599             CHECK_MBEDTLS_RET(mbedtls_x509_crt_parse, crt, buf + pos, len);
 600             pos += len;
 601         }
 602         else
 603         {
 604              OIC_LOG_BUFFER(DEBUG, NET_SSL_TAG, buf, bufLen);
 605              OIC_LOG_V(ERROR, NET_SSL_TAG, "parseChain returned -0x%x", -ret);
 606              OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 607              return -1;
 608         }
 609     }
 610     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 611     return 0;
 612
 613 exit:
 614     return -1;
 615 }
 616
 617 //Loads PKIX related information from SRM
 618 static int InitPKIX(CATransportAdapter_t adapter)
 619 {
 620     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 621     VERIFY_NON_NULL_RET(g_getPkixInfoCallback, NET_SSL_TAG, "PKIX info callback is NULL", -1);
 622     g_getPkixInfoCallback(&g_pkiInfo);
 623
 624     mbedtls_x509_crt_free(&g_caSslContext->ca);
 625     mbedtls_x509_crt_free(&g_caSslContext->crt);
 626     mbedtls_pk_free(&g_caSslContext->pkey);
 627     mbedtls_x509_crl_free(&g_caSslContext->crl);
 628
 629     mbedtls_x509_crt_init(&g_caSslContext->ca);
 630     mbedtls_x509_crt_init(&g_caSslContext->crt);
 631     mbedtls_pk_init(&g_caSslContext->pkey);
 632     mbedtls_x509_crl_init(&g_caSslContext->crl);
 633
 634     mbedtls_ssl_config * serverConf = (adapter == CA_ADAPTER_IP ?
 635                                    &g_caSslContext->serverDtlsConf : &g_caSslContext->serverTlsConf);
 636     mbedtls_ssl_config * clientConf = (adapter == CA_ADAPTER_IP ?
 637                                    &g_caSslContext->clientDtlsConf : &g_caSslContext->clientTlsConf);
 638     // optional
 639     int ret = ParseChain(&g_caSslContext->crt, g_pkiInfo.crt.data, g_pkiInfo.crt.len);
 640     if (0 != ret)
 641     {
 642         OIC_LOG(WARNING, NET_SSL_TAG, "Own certificate chain parsing error");
 643         goto required;
 644     }
 645     ret =  mbedtls_pk_parse_key(&g_caSslContext->pkey, g_pkiInfo.key.data, g_pkiInfo.key.len,
 646                                                                                NULL, 0);
 647     if (0 != ret)
 648     {
 649         OIC_LOG(WARNING, NET_SSL_TAG, "Key parsing error");
 650         goto required;
 651     }
 652
 653     ret = mbedtls_ssl_conf_own_cert(serverConf, &g_caSslContext->crt, &g_caSslContext->pkey);
 654     if (0 != ret)
 655     {
 656         OIC_LOG(WARNING, NET_SSL_TAG, "Own certificate parsing error");
 657         goto required;
 658     }
 659     ret = mbedtls_ssl_conf_own_cert(clientConf, &g_caSslContext->crt, &g_caSslContext->pkey);
 660     if(0 != ret)
 661     {
 662         OIC_LOG(WARNING, NET_SSL_TAG, "Own certificate configuration error");
 663         goto required;
 664     }
 665
 666     required:
 667     ret = ParseChain(&g_caSslContext->ca, g_pkiInfo.ca.data, g_pkiInfo.ca.len);
 668     if(0 != ret)
 669     {
 670         OIC_LOG(ERROR, NET_SSL_TAG, "CA chain parsing error");
 671         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 672         return -1;
 673     }
 674
 675     ret = mbedtls_x509_crl_parse_der(&g_caSslContext->crl, g_pkiInfo.crl.data, g_pkiInfo.crl.len);
 676     if(0 != ret)
 677     {
 678         OIC_LOG(WARNING, NET_SSL_TAG, "CRL parsing error");
 679         mbedtls_ssl_conf_ca_chain(clientConf, &g_caSslContext->ca, NULL);
 680         mbedtls_ssl_conf_ca_chain(serverConf, &g_caSslContext->ca, NULL);
 681     }
 682     else
 683     {
 684         mbedtls_ssl_conf_ca_chain(clientConf, &g_caSslContext->ca, &g_caSslContext->crl);
 685         mbedtls_ssl_conf_ca_chain(serverConf, &g_caSslContext->ca, &g_caSslContext->crl);
 686     }
 687
 688     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 689     return 0;
 690 }
 691
 692 /*
 693  * PSK callback.
 694  *
 695  * @param[in]  notUsed     opaque context
 696  * @param[in]  ssl    mbedTLS context
 697  * @param[in]  desc    identity
 698  * @param[in]  descLen    identity length
 699  *
 700  * @return  0 on success any other return value will result in a denied PSK identity
 701  */
 702 static int GetPskCredentialsCallback(void * notUsed, mbedtls_ssl_context * ssl,
 703                                      const unsigned char * desc, size_t descLen)
 704 {
 705     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 706     VERIFY_NON_NULL_RET(g_getCredentialsCallback, NET_SSL_TAG, "Credential callback s NULL", -1);
 707     VERIFY_NON_NULL_RET(ssl, NET_SSL_TAG, "ssl pointer is NULL", -1);
 708     VERIFY_NON_NULL_RET(desc, NET_SSL_TAG, "desc pointer is NULL", -1);
 709     if (descLen > CA_MAX_ENDPOINT_IDENTITY_LEN)
 710     {
 711         OIC_LOG(ERROR, NET_SSL_TAG, "desc too long!");
 712         return -1;
 713     }
 714     (void) notUsed;
 715     uint8_t keyBuf[PSK_LENGTH] = {0};
 716
 717     // Retrieve the credentials blob from security module
 718     int ret = g_getCredentialsCallback(CA_DTLS_PSK_KEY, desc, descLen, keyBuf, PSK_LENGTH);
 719     if (ret > 0)
 720     {
 721         memcpy(((SslEndPoint_t *) ssl)->sep.identity.id, desc, descLen);
 722         ((SslEndPoint_t *) ssl)->sep.identity.id_length = descLen;
 723         OIC_LOG(DEBUG, NET_SSL_TAG, "PSK:");
 724         OIC_LOG_BUFFER(DEBUG, NET_SSL_TAG, keyBuf, ret);
 725
 726         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 727         return(mbedtls_ssl_set_hs_psk(ssl, keyBuf, ret));
 728     }
 729     OIC_LOG_V(WARNING, NET_SSL_TAG, "Out %s", __func__);
 730     return -1;
 731 }
 732 /**
 733  * Gets session corresponding for endpoint.
 734  *
 735  * @param[in]  peer    remote address
 736  *
 737  * @return  TLS session or NULL
 738  */
 739 static SslEndPoint_t *GetSslPeer(const CAEndpoint_t *peer)
 740 {
 741     uint32_t listIndex = 0;
 742     uint32_t listLength = 0;
 743     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 744     VERIFY_NON_NULL_RET(peer, NET_SSL_TAG, "TLS peer is NULL", NULL);
 745
 746     SslEndPoint_t *tep = NULL;
 747     listLength = u_arraylist_length(g_caSslContext->peerList);
 748     for (listIndex = 0; listIndex < listLength; listIndex++)
 749     {
 750         tep = (SslEndPoint_t *) u_arraylist_get(g_caSslContext->peerList, listIndex);
 751         if (NULL == tep)
 752         {
 753             continue;
 754         }
 755         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Compare [%s:%d] and [%s:%d]",
 756                   peer->addr, peer->port, tep->sep.endpoint.addr, tep->sep.endpoint.port);
 757         if((0 == strncmp(peer->addr, tep->sep.endpoint.addr, MAX_ADDR_STR_SIZE_CA))
 758                 && (peer->port == tep->sep.endpoint.port))
 759         {
 760             OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 761             return tep;
 762         }
 763     }
 764     OIC_LOG(DEBUG, NET_SSL_TAG, "Return NULL");
 765     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 766     return NULL;
 767 }
 768 /**
 769  * Deletes cached message.
 770  *
 771  * @param[in]  msg    message
 772  */
 773 static void DeleteCacheMessage(SslCacheMessage_t * msg)
 774 {
 775     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 776     VERIFY_NON_NULL_VOID(msg, NET_SSL_TAG, "msg");
 777
 778     OICFree(msg->data);
 779     OICFree(msg);
 780
 781     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 782 }
 783 /**
 784  * Deletes cached message list.
 785  *
 786  * @param[in] cacheList  list of cached messages
 787  */
 788 static void DeleteCacheList(u_arraylist_t * cacheList)
 789 {
 790     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 791     VERIFY_NON_NULL_VOID(cacheList, NET_SSL_TAG, "cacheList");
 792     uint32_t listIndex = 0;
 793     uint32_t listLength = 0;
 794
 795     listLength = u_arraylist_length(cacheList);
 796     for (listIndex = 0; listIndex < listLength; listIndex++)
 797     {
 798         SslCacheMessage_t * msg = (SslCacheMessage_t *) u_arraylist_get(cacheList, listIndex);
 799         if (NULL != msg)
 800         {
 801             DeleteCacheMessage(msg);
 802         }
 803     }
 804     u_arraylist_free(&cacheList);
 805
 806     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 807 }
 808 /**
 809  * Deletes endpoint with session.
 810  *
 811  * @param[in]  tep    endpoint with session info
 812  */
 813 static void DeleteSslEndPoint(SslEndPoint_t * tep)
 814 {
 815     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 816     VERIFY_NON_NULL_VOID(tep, NET_SSL_TAG, "tep");
 817
 818     mbedtls_ssl_free(&tep->ssl);
 819 #ifdef __WITH_DTLS__
 820     mbedtls_ssl_cookie_free(&tep->cookieCtx);
 821 #endif
 822     DeleteCacheList(tep->cacheList);
 823     OICFree(tep);
 824     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 825 }
 826 /**
 827  * Removes endpoint session from list.
 828  *
 829  * @param[in]  endpoint    remote address
 830  */
 831 static void RemovePeerFromList(CAEndpoint_t * endpoint)
 832 {
 833     uint32_t listLength = u_arraylist_length(g_caSslContext->peerList);
 834     VERIFY_NON_NULL_VOID(endpoint, NET_SSL_TAG, "endpoint");
 835     for (uint32_t listIndex = 0; listIndex < listLength; listIndex++)
 836     {
 837         SslEndPoint_t * tep = (SslEndPoint_t *)u_arraylist_get(g_caSslContext->peerList,listIndex);
 838         if (NULL == tep)
 839         {
 840             continue;
 841         }
 842         if(0 == strncmp(endpoint->addr, tep->sep.endpoint.addr, MAX_ADDR_STR_SIZE_CA)
 843                 && (endpoint->port == tep->sep.endpoint.port))
 844         {
 845             u_arraylist_remove(g_caSslContext->peerList, listIndex);
 846             DeleteSslEndPoint(tep);
 847             return;
 848         }
 849     }
 850 }
 851 /**
 852  * Deletes session list.
 853  */
 854 static void DeletePeerList()
 855 {
 856     uint32_t listLength = u_arraylist_length(g_caSslContext->peerList);
 857     for (uint32_t listIndex = 0; listIndex < listLength; listIndex++)
 858     {
 859         SslEndPoint_t * tep = (SslEndPoint_t *)u_arraylist_get(g_caSslContext->peerList,listIndex);
 860         if (NULL == tep)
 861         {
 862             continue;
 863         }
 864         DeleteSslEndPoint(tep);
 865     }
 866     u_arraylist_free(&g_caSslContext->peerList);
 867 }
 868
 869 CAResult_t CAcloseSslConnection(const CAEndpoint_t *endpoint)
 870 {
 871     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 872     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG, "Param endpoint is NULL" , CA_STATUS_INVALID_PARAM);
 873
 874     ca_mutex_lock(g_sslContextMutex);
 875     if (NULL == g_caSslContext)
 876     {
 877         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
 878         ca_mutex_unlock(g_sslContextMutex);
 879         return CA_STATUS_FAILED;
 880     }
 881     SslEndPoint_t * tep = GetSslPeer(endpoint);
 882     if (NULL == tep)
 883     {
 884         OIC_LOG(ERROR, NET_SSL_TAG, "Session does not exist");
 885         ca_mutex_unlock(g_sslContextMutex);
 886         return CA_STATUS_FAILED;
 887     }
 888     /* No error checking, the connection might be closed already */
 889     int ret = 0;
 890     do
 891     {
 892         ret = mbedtls_ssl_close_notify(&tep->ssl);
 893     }
 894     while (MBEDTLS_ERR_SSL_WANT_WRITE == ret);
 895
 896     RemovePeerFromList(&tep->sep.endpoint);
 897     ca_mutex_unlock(g_sslContextMutex);
 898
 899     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 900     return CA_STATUS_OK;
 901 }
 902 /**
 903  * Creates session for endpoint.
 904  *
 905  * @param[in]  endpoint    remote address
 906  * @param[in]  config    mbedTLS configuration info
 907  *
 908  * @return  TLS endpoint or NULL
 909  */
 910 static SslEndPoint_t * NewSslEndPoint(const CAEndpoint_t * endpoint, mbedtls_ssl_config * config)
 911 {
 912     SslEndPoint_t * tep = NULL;
 913     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 914     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG, "endpoint", NULL);
 915     VERIFY_NON_NULL_RET(config, NET_SSL_TAG, "config", NULL);
 916
 917     tep = (SslEndPoint_t *) OICCalloc(1, sizeof (SslEndPoint_t));
 918     if (NULL == tep)
 919     {
 920         OIC_LOG(ERROR, NET_SSL_TAG, "Malloc failed!");
 921         return NULL;
 922     }
 923
 924     tep->sep.endpoint = *endpoint;
 925     tep->sep.endpoint.flags = (CATransportFlags_t)(tep->sep.endpoint.flags | CA_SECURE);
 926
 927     if(0 != mbedtls_ssl_setup(&tep->ssl, config))
 928     {
 929         OIC_LOG(ERROR, NET_SSL_TAG, "Setup failed");
 930         OICFree(tep);
 931         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 932         return NULL;
 933     }
 934
 935     mbedtls_ssl_set_bio(&tep->ssl, tep, SendCallBack, RecvCallBack, NULL);
 936     if (MBEDTLS_SSL_TRANSPORT_DATAGRAM == config->transport)
 937     {
 938         mbedtls_ssl_set_timer_cb(&tep->ssl, &g_caSslContext->timer,
 939                                   mbedtls_timing_set_delay, mbedtls_timing_get_delay);
 940         if (MBEDTLS_SSL_IS_SERVER == config->endpoint)
 941         {
 942             if (0 != mbedtls_ssl_cookie_setup(&tep->cookieCtx, mbedtls_ctr_drbg_random,
 943                                               &g_caSslContext->rnd))
 944             {
 945                 OIC_LOG(ERROR, NET_SSL_TAG, "Cookie setup failed!");
 946                 OICFree(tep);
 947                 OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 948                 return NULL;
 949             }
 950             mbedtls_ssl_conf_dtls_cookies(config, mbedtls_ssl_cookie_write, mbedtls_ssl_cookie_check,
 951                                           &tep->cookieCtx);
 952             if (0 != mbedtls_ssl_set_client_transport_id(&tep->ssl,
 953                                     (const unsigned char *) endpoint->addr, sizeof(endpoint->addr)))
 954             {
 955                 OIC_LOG(ERROR, NET_SSL_TAG, "Transport id setup failed!");
 956                 OICFree(tep);
 957                 OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 958                 return NULL;
 959             }
 960         }
 961     }
 962     tep->cacheList = u_arraylist_create();
 963     if (NULL == tep->cacheList)
 964     {
 965         OIC_LOG(ERROR, NET_SSL_TAG, "cacheList initialization failed!");
 966         mbedtls_ssl_free(&tep->ssl);
 967         OICFree(tep);
 968         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 969         return NULL;
 970     }
 971     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 972     return tep;
 973 }
 974 /**
 975  * Initializes PSK identity.
 976  *
 977  * @param[out]  config    client/server config to be updated
 978  *
 979  * @return  0 on success or -1 on error
 980  */
 981 static int InitPskIdentity(mbedtls_ssl_config * config)
 982 {
 983     uint8_t idBuf[UUID_LENGTH] = {0};
 984     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 985     VERIFY_NON_NULL_RET(config, NET_SSL_TAG, "Param config is NULL" , -1);
 986
 987     if (0 > g_getCredentialsCallback(CA_DTLS_PSK_IDENTITY, NULL, 0, idBuf, UUID_LENGTH))
 988     {
 989         OIC_LOG(ERROR, NET_SSL_TAG, "Identity not found");
 990         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 991         return -1;
 992     }
 993     if (0 != mbedtls_ssl_conf_psk(config, idBuf, 0, idBuf, UUID_LENGTH))
 994     {
 995         OIC_LOG(ERROR, NET_SSL_TAG, "Identity initialization failed!");
 996         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 997         return -1;
 998     }
 999     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1000     return 0;
1001 }
1002 static void SetupCipher(mbedtls_ssl_config * config, CATransportAdapter_t adapter)
1003 {
1004     int index = 0;
1005     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1006     if (NULL == g_getCredentialTypesCallback)
1007     {
1008         OIC_LOG(ERROR, NET_SSL_TAG, "Param callback is null");
1009         return;
1010     }
1011
1012     g_getCredentialTypesCallback(g_caSslContext->cipherFlag);
1013     // Retrieve the PSK credential from SRM
1014     // PIN OTM if (true == g_caSslContext->cipherFlag[0] && 0 != InitPskIdentity(config))
1015     if (0 != InitPskIdentity(config))
1016     {
1017         OIC_LOG(ERROR, NET_SSL_TAG, "PSK identity initialization failed!");
1018     }
1019
1020     // Retrieve the ECC credential from SRM
1021     if (true == g_caSslContext->cipherFlag[1] || ADAPTER_TLS_RSA_WITH_AES_256_CBC_SHA == g_caSslContext->cipher)
1022     {
1023         int ret = InitPKIX(adapter);
1024         if (0 != ret)
1025         {
1026             OIC_LOG(ERROR, NET_SSL_TAG, "Failed to init X.509");
1027         }
1028     }
1029
1030     memset(g_cipherSuitesList, 0, sizeof(g_cipherSuitesList));
1031     if (ADAPTER_CIPHER_MAX != g_caSslContext->cipher)
1032     {
1033         g_cipherSuitesList[index] = tlsCipher[g_caSslContext->cipher][0];
1034         index ++;
1035     }
1036     if (true == g_caSslContext->cipherFlag[1])
1037     {
1038         g_cipherSuitesList[index] = MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8;
1039         index ++;
1040     }
1041     if (true == g_caSslContext->cipherFlag[0])
1042     {
1043        g_cipherSuitesList[index] = MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256;
1044     }
1045
1046     mbedtls_ssl_conf_ciphersuites(config, g_cipherSuitesList);
1047
1048     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1049 }
1050 /**
1051  * Initiate TLS handshake with endpoint.
1052  *
1053  * @param[in]  endpoint    remote address
1054  *
1055  * @return  TLS endpoint or NULL
1056  */
1057 static SslEndPoint_t * InitiateTlsHandshake(const CAEndpoint_t *endpoint)
1058 {
1059     int ret = 0;
1060     SslEndPoint_t * tep = NULL;
1061
1062     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1063     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG, "Param endpoint is NULL" , NULL);
1064
1065
1066     mbedtls_ssl_config * config = (endpoint->adapter == CA_ADAPTER_IP ?
1067                                    &g_caSslContext->clientDtlsConf : &g_caSslContext->clientTlsConf);
1068     tep = NewSslEndPoint(endpoint, config);
1069     if (NULL == tep)
1070     {
1071         OIC_LOG(ERROR, NET_SSL_TAG, "Malloc failed!");
1072         return NULL;
1073     }
1074
1075     //Load allowed SVR suites from SVR DB
1076     SetupCipher(config, endpoint->adapter);
1077
1078     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Add %s:%d", tep->sep.endpoint.addr, tep->sep.endpoint.port);
1079     ret = u_arraylist_add(g_caSslContext->peerList, (void *) tep);
1080     if (!ret)
1081     {
1082         OIC_LOG(ERROR, NET_SSL_TAG, "u_arraylist_add failed!");
1083         DeleteSslEndPoint(tep);
1084         return NULL;
1085     }
1086
1087     while (MBEDTLS_SSL_HANDSHAKE_OVER > tep->ssl.state)
1088     {
1089         ret = mbedtls_ssl_handshake_step(&tep->ssl);
1090         if (MBEDTLS_ERR_SSL_CONN_EOF == ret)
1091         {
1092             break;
1093         }
1094         SSL_CHECK_FAIL(tep, ret, "Handshake error", 0, NULL, MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE);
1095     }
1096     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1097     return tep;
1098 }
1099
1100 void CAdeinitSslAdapter()
1101 {
1102     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1103
1104     VERIFY_NON_NULL_VOID(g_caSslContext, NET_SSL_TAG, "context is NULL");
1105     VERIFY_NON_NULL_VOID(g_sslContextMutex, NET_SSL_TAG, "context mutex is NULL");
1106
1107     //Lock tlsContext mutex
1108     ca_mutex_lock(g_sslContextMutex);
1109
1110     // Clear all lists
1111     DeletePeerList();
1112
1113     // De-initialize mbedTLS
1114     mbedtls_x509_crt_free(&g_caSslContext->crt);
1115     mbedtls_pk_free(&g_caSslContext->pkey);
1116 #ifdef __WITH_TLS__
1117     mbedtls_ssl_config_free(&g_caSslContext->clientTlsConf);
1118     mbedtls_ssl_config_free(&g_caSslContext->serverTlsConf);
1119 #endif // __WITH_TLS__
1120 #ifdef __WITH_DTLS__
1121     mbedtls_ssl_config_free(&g_caSslContext->clientDtlsConf);
1122     mbedtls_ssl_config_free(&g_caSslContext->serverDtlsConf);
1123 #endif // __WITH_DTLS__
1124     mbedtls_ctr_drbg_free(&g_caSslContext->rnd);
1125     mbedtls_entropy_free(&g_caSslContext->entropy);
1126
1127     // De-initialize tls Context
1128     OICFree(g_caSslContext);
1129     g_caSslContext = NULL;
1130
1131     // Unlock tlsContext mutex and de-initialize it
1132     ca_mutex_unlock(g_sslContextMutex);
1133     ca_mutex_free(g_sslContextMutex);
1134     g_sslContextMutex = NULL;
1135
1136     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s ", __func__);
1137 }
1138
1139 static int InitConfig(mbedtls_ssl_config * conf, int transport, int mode)
1140 {
1141     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1142     VERIFY_NON_NULL_RET(conf, NET_SSL_TAG, "Param conf is NULL" , -1);
1143     mbedtls_ssl_config_init(conf);
1144     if (mbedtls_ssl_config_defaults(conf, mode, transport, MBEDTLS_SSL_PRESET_DEFAULT) != 0)
1145     {
1146         OIC_LOG(ERROR, NET_SSL_TAG, "Config initialization failed!");
1147         return -1;
1148     }
1149
1150     mbedtls_ssl_conf_psk_cb(conf, GetPskCredentialsCallback, NULL);
1151     mbedtls_ssl_conf_rng(conf, mbedtls_ctr_drbg_random, &g_caSslContext->rnd);
1152     mbedtls_ssl_conf_curves(conf, curve[ADAPTER_CURVE_SECP256R1]);
1153     mbedtls_ssl_conf_min_version(conf, MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3);
1154     mbedtls_ssl_conf_renegotiation(conf, MBEDTLS_SSL_RENEGOTIATION_DISABLED);
1155     mbedtls_ssl_conf_authmode(conf, MBEDTLS_SSL_VERIFY_REQUIRED);
1156
1157 #ifndef NDEBUG
1158     mbedtls_ssl_conf_dbg(conf, DebugSsl, NULL);
1159     mbedtls_debug_set_threshold(MBED_TLS_DEBUG_LEVEL);
1160 #endif
1161     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1162     return 0;
1163 }
1164
1165 CAResult_t CAinitSslAdapter()
1166 {
1167     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1168     // Initialize mutex for tlsContext
1169     if (NULL == g_sslContextMutex)
1170     {
1171         g_sslContextMutex = ca_mutex_new();
1172         VERIFY_NON_NULL_RET(g_sslContextMutex, NET_SSL_TAG, "malloc failed", CA_MEMORY_ALLOC_FAILED);
1173     }
1174     else
1175     {
1176         OIC_LOG(INFO, NET_SSL_TAG, "Done already!");
1177         return CA_STATUS_OK;
1178     }
1179
1180     // Lock tlsContext mutex and create tlsContext
1181     ca_mutex_lock(g_sslContextMutex);
1182     g_caSslContext = (SslContext_t *)OICCalloc(1, sizeof(SslContext_t));
1183
1184     if (NULL == g_caSslContext)
1185     {
1186         OIC_LOG(ERROR, NET_SSL_TAG, "Context malloc failed");
1187         ca_mutex_unlock(g_sslContextMutex);
1188         ca_mutex_free(g_sslContextMutex);
1189         g_sslContextMutex = NULL;
1190         return CA_MEMORY_ALLOC_FAILED;
1191     }
1192
1193     // Create peer list
1194     g_caSslContext->peerList = u_arraylist_create();
1195
1196     if(NULL == g_caSslContext->peerList)
1197     {
1198         OIC_LOG(ERROR, NET_SSL_TAG, "peerList initialization failed!");
1199         OICFree(g_caSslContext);
1200         g_caSslContext = NULL;
1201         ca_mutex_unlock(g_sslContextMutex);
1202         ca_mutex_free(g_sslContextMutex);
1203         g_sslContextMutex = NULL;
1204         return CA_STATUS_FAILED;
1205     }
1206
1207     /* Initialize TLS library
1208      */
1209 #ifndef NDEBUG
1210     char version[MBED_TLS_VERSION_LEN];
1211     mbedtls_version_get_string(version);
1212     OIC_LOG_V(INFO, NET_SSL_TAG, "mbed TLS version: %s", version);
1213 #endif
1214
1215     /* Entropy settings
1216      */
1217     mbedtls_entropy_init(&g_caSslContext->entropy);
1218     mbedtls_ctr_drbg_init(&g_caSslContext->rnd);
1219
1220 #ifdef __unix__
1221     unsigned char seed[sizeof(SEED)] = {0};
1222     int urandomFd = -2;
1223     urandomFd = open("/dev/urandom", O_RDONLY);
1224     if(urandomFd == -1)
1225     {
1226         OIC_LOG(ERROR, NET_SSL_TAG, "Fails open /dev/urandom!");
1227         ca_mutex_unlock(g_sslContextMutex);
1228         CAdeinitSslAdapter();
1229         return CA_STATUS_FAILED;
1230     }
1231     if(0 > read(urandomFd, seed, sizeof(seed)))
1232     {
1233         OIC_LOG(ERROR, NET_SSL_TAG, "Fails read from /dev/urandom!");
1234         close(urandomFd);
1235         ca_mutex_unlock(g_sslContextMutex);
1236         CAdeinitSslAdapter();
1237         return CA_STATUS_FAILED;
1238     }
1239     close(urandomFd);
1240
1241 #else
1242     unsigned char * seed = (unsigned char*) SEED;
1243 #endif
1244     if(0 != mbedtls_ctr_drbg_seed(&g_caSslContext->rnd, mbedtls_entropy_func,
1245                                   &g_caSslContext->entropy, seed, sizeof(SEED)))
1246     {
1247         OIC_LOG(ERROR, NET_SSL_TAG, "Seed initialization failed!");
1248         ca_mutex_unlock(g_sslContextMutex);
1249         CAdeinitSslAdapter();
1250         return CA_STATUS_FAILED;
1251     }
1252     mbedtls_ctr_drbg_set_prediction_resistance(&g_caSslContext->rnd, MBEDTLS_CTR_DRBG_PR_OFF);
1253
1254 #ifdef __WITH_TLS__
1255     if (0 != InitConfig(&g_caSslContext->clientTlsConf,
1256                         MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_IS_CLIENT))
1257     {
1258         OIC_LOG(ERROR, NET_SSL_TAG, "Client config initialization failed!");
1259         ca_mutex_unlock(g_sslContextMutex);
1260         CAdeinitSslAdapter();
1261         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1262         return CA_STATUS_FAILED;
1263     }
1264
1265     if (0 != InitConfig(&g_caSslContext->serverTlsConf,
1266                         MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_IS_SERVER))
1267     {
1268         OIC_LOG(ERROR, NET_SSL_TAG, "Server config initialization failed!");
1269         ca_mutex_unlock(g_sslContextMutex);
1270         CAdeinitSslAdapter();
1271         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1272         return CA_STATUS_FAILED;
1273     }
1274 #endif // __WITH_TLS__
1275 #ifdef __WITH_DTLS__
1276     if (0 != InitConfig(&g_caSslContext->clientDtlsConf,
1277                         MBEDTLS_SSL_TRANSPORT_DATAGRAM, MBEDTLS_SSL_IS_CLIENT))
1278     {
1279         OIC_LOG(ERROR, NET_SSL_TAG, "Client config initialization failed!");
1280         ca_mutex_unlock(g_sslContextMutex);
1281         CAdeinitSslAdapter();
1282         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1283         return CA_STATUS_FAILED;
1284     }
1285
1286     if (0 != InitConfig(&g_caSslContext->serverDtlsConf,
1287                         MBEDTLS_SSL_TRANSPORT_DATAGRAM, MBEDTLS_SSL_IS_SERVER))
1288     {
1289         OIC_LOG(ERROR, NET_SSL_TAG, "Server config initialization failed!");
1290         ca_mutex_unlock(g_sslContextMutex);
1291         CAdeinitSslAdapter();
1292         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1293         return CA_STATUS_FAILED;
1294     }
1295 #endif // __WITH_DTLS__
1296
1297     // set default cipher
1298     g_caSslContext->cipher = ADAPTER_CIPHER_MAX;
1299
1300     // init X.509
1301     mbedtls_x509_crt_init(&g_caSslContext->ca);
1302     mbedtls_x509_crt_init(&g_caSslContext->crt);
1303     mbedtls_pk_init(&g_caSslContext->pkey);
1304     mbedtls_x509_crl_init(&g_caSslContext->crl);
1305
1306     ca_mutex_unlock(g_sslContextMutex);
1307
1308     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1309     return CA_STATUS_OK;
1310 }
1311
1312 SslCacheMessage_t *  NewCacheMessage(uint8_t * data, size_t dataLen)
1313 {
1314     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1315     VERIFY_NON_NULL_RET(data, NET_SSL_TAG, "Param data is NULL" , NULL);
1316     if (0 == dataLen)
1317     {
1318         OIC_LOG(ERROR, NET_SSL_TAG, "dataLen is equal to zero");
1319         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1320         return NULL;
1321     }
1322     SslCacheMessage_t * message = (SslCacheMessage_t *) OICCalloc(1, sizeof(SslCacheMessage_t));
1323     if (NULL == message)
1324     {
1325         OIC_LOG(ERROR, NET_SSL_TAG, "calloc failed!");
1326         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1327         return NULL;
1328     }
1329
1330     message->data = (uint8_t *)OICCalloc(dataLen, sizeof(uint8_t));
1331     if (NULL == message->data)
1332     {
1333         OIC_LOG(ERROR, NET_SSL_TAG, "calloc failed!");
1334         OICFree(message);
1335         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1336         return NULL;
1337     }
1338     memcpy(message->data, data, dataLen);
1339     message->len = dataLen;
1340     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1341     return message;
1342 }
1343
1344 /* Send data via TLS connection.
1345  */
1346 CAResult_t CAencryptSsl(const CAEndpoint_t *endpoint,
1347                         void *data, uint32_t dataLen)
1348 {
1349     int ret = 0;
1350
1351     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s ", __func__);
1352
1353     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG,"Remote address is NULL", CA_STATUS_INVALID_PARAM);
1354     VERIFY_NON_NULL_RET(data, NET_SSL_TAG, "Data is NULL", CA_STATUS_INVALID_PARAM);
1355     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Port %d", endpoint->port);
1356
1357     if (0 == dataLen)
1358     {
1359         OIC_LOG_V(ERROR, NET_SSL_TAG, "dataLen is zero [%d]", dataLen);
1360         return CA_STATUS_FAILED;
1361     }
1362
1363     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Data to be encrypted dataLen [%d]", dataLen);
1364
1365     ca_mutex_lock(g_sslContextMutex);
1366     if(NULL == g_caSslContext)
1367     {
1368         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
1369         ca_mutex_unlock(g_sslContextMutex);
1370         return CA_STATUS_FAILED;
1371     }
1372
1373     SslEndPoint_t * tep = GetSslPeer(endpoint);
1374     if (NULL == tep)
1375     {
1376         tep = InitiateTlsHandshake(endpoint);
1377     }
1378     if (NULL == tep)
1379     {
1380         OIC_LOG(ERROR, NET_SSL_TAG, "TLS handshake failed");
1381         ca_mutex_unlock(g_sslContextMutex);
1382         return CA_STATUS_FAILED;
1383     }
1384
1385     if (MBEDTLS_SSL_HANDSHAKE_OVER == tep->ssl.state)
1386     {
1387         ret = mbedtls_ssl_write(&tep->ssl, (unsigned char *) data, dataLen);
1388
1389         if(ret < 0)
1390         {
1391             OIC_LOG_V(ERROR, NET_SSL_TAG, "mbedTLS write returned %d", ret);
1392             RemovePeerFromList(&tep->sep.endpoint);
1393             ca_mutex_unlock(g_sslContextMutex);
1394             return CA_STATUS_FAILED;
1395         }
1396     }
1397     else
1398     {
1399         SslCacheMessage_t * msg = NewCacheMessage((uint8_t*) data, dataLen);
1400         if (NULL == msg || !u_arraylist_add(tep->cacheList, (void *) msg))
1401         {
1402             OIC_LOG(ERROR, NET_SSL_TAG, "u_arraylist_add failed!");
1403             ca_mutex_unlock(g_sslContextMutex);
1404             return CA_STATUS_FAILED;
1405         }
1406     }
1407
1408     ca_mutex_unlock(g_sslContextMutex);
1409
1410     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1411     return CA_STATUS_OK;
1412 }
1413 /**
1414  * Sends cached messages via TLS connection.
1415  *
1416  * @param[in]  tep    remote address with session info
1417  */
1418 static void SendCacheMessages(SslEndPoint_t * tep)
1419 {
1420     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1421     VERIFY_NON_NULL_VOID(tep, NET_SSL_TAG, "Param tep is NULL");
1422
1423     uint32_t listIndex = 0;
1424     uint32_t listLength = 0;
1425     listLength = u_arraylist_length(tep->cacheList);
1426     for (listIndex = 0; listIndex < listLength;)
1427     {
1428         int ret = 0;
1429         SslCacheMessage_t * msg = (SslCacheMessage_t *) u_arraylist_get(tep->cacheList, listIndex);
1430         if (NULL != msg && NULL != msg->data && 0 != msg->len)
1431         {
1432             do
1433             {
1434                 ret = mbedtls_ssl_write(&tep->ssl, (unsigned char *) msg->data, msg->len);
1435             }
1436             while(MBEDTLS_ERR_SSL_WANT_WRITE == ret);
1437
1438             if(ret < 0)
1439             {
1440                 OIC_LOG_V(ERROR, NET_SSL_TAG,"mbedTLS write returned %d", ret );
1441             }
1442             if (u_arraylist_remove(tep->cacheList, listIndex))
1443             {
1444                 DeleteCacheMessage(msg);
1445                 // Reduce list length by 1 as we removed one element.
1446                 listLength--;
1447             }
1448             else
1449             {
1450                 OIC_LOG(ERROR, NET_SSL_TAG, "u_arraylist_remove failed.");
1451                 break;
1452             }
1453         }
1454         else
1455         {
1456             // Move to the next element
1457             ++listIndex;
1458         }
1459     }
1460     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1461 }
1462
1463 void CAsetSslHandshakeCallback(CAErrorCallback tlsHandshakeCallback)
1464 {
1465     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1466     g_sslCallback = tlsHandshakeCallback;
1467     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1468 }
1469 // TODO move ConvertStrToUuid function to common module
1470 /*
1471  * Converts string UUID to CARemoteId_t
1472  *
1473  * @param strUuid Device UUID in string format
1474  * @param uuid converted UUID in CARemoteId_t format
1475  *
1476  * @return 0 for success.
1477  * */
1478 static int ConvertStrToUuid(const char* strUuid, CARemoteId_t* uuid)
1479 {
1480     if(NULL == strUuid || NULL == uuid)
1481     {
1482         OIC_LOG(ERROR, NET_SSL_TAG, "ConvertStrToUuid : Invalid param");
1483         return -1;
1484     }
1485
1486     size_t urnIdx = 0;
1487     size_t uuidIdx = 0;
1488     size_t strUuidLen = 0;
1489     char convertedUuid[UUID_LENGTH * 2] = {0};
1490
1491     strUuidLen = strlen(strUuid);
1492     if(0 == strUuidLen)
1493     {
1494         OIC_LOG(INFO, NET_SSL_TAG, "The empty string detected, The UUID will be converted to "\
1495                            "\"00000000-0000-0000-0000-000000000000\"");
1496     }
1497     else if(UUID_LENGTH * 2 + 4 == strUuidLen)
1498     {
1499         for(uuidIdx=0, urnIdx=0; uuidIdx < UUID_LENGTH ; uuidIdx++, urnIdx+=2)
1500         {
1501             if(*(strUuid + urnIdx) == '-')
1502             {
1503                 urnIdx++;
1504             }
1505             sscanf(strUuid + urnIdx, "%2hhx", &convertedUuid[uuidIdx]);
1506         }
1507     }
1508     else
1509     {
1510         OIC_LOG(ERROR, NET_SSL_TAG, "Invalid string uuid format");
1511         return -1;
1512     }
1513
1514     memcpy(uuid->id, convertedUuid, UUID_LENGTH);
1515     uuid->id_length = UUID_LENGTH;
1516     return 0;
1517 }
1518
1519 /* Read data from TLS connection
1520  */
1521 CAResult_t CAdecryptSsl(const CASecureEndpoint_t *sep, uint8_t *data, uint32_t dataLen)
1522 {
1523     int ret = 0;
1524     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1525     VERIFY_NON_NULL_RET(sep, NET_SSL_TAG, "endpoint is NULL" , CA_STATUS_INVALID_PARAM);
1526     VERIFY_NON_NULL_RET(data, NET_SSL_TAG, "Param data is NULL" , CA_STATUS_INVALID_PARAM);
1527
1528     ca_mutex_lock(g_sslContextMutex);
1529     if (NULL == g_caSslContext)
1530     {
1531         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
1532         ca_mutex_unlock(g_sslContextMutex);
1533         return CA_STATUS_FAILED;
1534     }
1535
1536
1537     SslEndPoint_t * peer = GetSslPeer(&sep->endpoint);
1538     if (NULL == peer)
1539     {
1540         mbedtls_ssl_config * config = (sep->endpoint.adapter == CA_ADAPTER_IP ?
1541                                    &g_caSslContext->serverDtlsConf : &g_caSslContext->serverTlsConf);
1542         peer = NewSslEndPoint(&sep->endpoint, config);
1543         if (NULL == peer)
1544         {
1545             OIC_LOG(ERROR, NET_SSL_TAG, "Malloc failed!");
1546             ca_mutex_unlock(g_sslContextMutex);
1547             return CA_STATUS_FAILED;
1548         }
1549         //Load allowed TLS suites from SVR DB
1550         SetupCipher(config, sep->endpoint.adapter);
1551
1552         ret = u_arraylist_add(g_caSslContext->peerList, (void *) peer);
1553         if (!ret)
1554         {
1555             OIC_LOG(ERROR, NET_SSL_TAG, "u_arraylist_add failed!");
1556             OICFree(peer);
1557             ca_mutex_unlock(g_sslContextMutex);
1558             return CA_STATUS_FAILED;
1559         }
1560     }
1561
1562     peer->recBuf.buff = data;
1563     peer->recBuf.len = dataLen;
1564     peer->recBuf.loaded = 0;
1565
1566     while (MBEDTLS_SSL_HANDSHAKE_OVER != peer->ssl.state)
1567     {
1568         ret = mbedtls_ssl_handshake_step(&peer->ssl);
1569         if (MBEDTLS_ERR_SSL_CONN_EOF == ret)
1570         {
1571             break;
1572         }
1573
1574         if (MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED == ret)
1575         {
1576             OIC_LOG(DEBUG, NET_SSL_TAG, "Hello verification requested");
1577             mbedtls_ssl_session_reset(&peer->ssl);
1578             mbedtls_ssl_set_client_transport_id(&peer->ssl,
1579                                                 (const unsigned char *) sep->endpoint.addr,
1580                                                  sizeof(sep->endpoint.addr));
1581             ret = mbedtls_ssl_handshake_step(&peer->ssl);
1582         }
1583         uint32_t flags = mbedtls_ssl_get_verify_result(&peer->ssl);
1584         if (0 != flags)
1585         {
1586             OIC_LOG_BUFFER(ERROR, NET_SSL_TAG, (const uint8_t *) &flags, sizeof(flags));
1587             SSL_CHECK_FAIL(peer, flags, "Cert verification failed", 1,
1588                                                      CA_STATUS_FAILED, GetAlertCode(flags));
1589         }
1590         SSL_CHECK_FAIL(peer, ret, "Handshake error", 1, CA_STATUS_FAILED, MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE);
1591         if (MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC == peer->ssl.state)
1592         {
1593             memcpy(peer->master, peer->ssl.session_negotiate->master, sizeof(peer->master));
1594             g_caSslContext->selectedCipher = peer->ssl.session_negotiate->ciphersuite;
1595         }
1596         if (MBEDTLS_SSL_CLIENT_KEY_EXCHANGE == peer->ssl.state)
1597         {
1598             memcpy(peer->random, peer->ssl.handshake->randbytes, sizeof(peer->random));
1599         }
1600
1601         if (MBEDTLS_SSL_HANDSHAKE_OVER == peer->ssl.state)
1602         {
1603             SSL_RES(peer, CA_STATUS_OK);
1604             if (MBEDTLS_SSL_IS_CLIENT == peer->ssl.conf->endpoint)
1605             {
1606                 SendCacheMessages(peer);
1607             }
1608
1609             if (MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8 == g_caSslContext->selectedCipher ||
1610                 MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA == g_caSslContext->selectedCipher)
1611             {
1612                 char uuid[UUID_LENGTH * 2 + 5] = {0};
1613                 void * uuidPos = NULL;
1614                 void * userIdPos = NULL;
1615                 const mbedtls_x509_crt * peerCert = mbedtls_ssl_get_peer_cert(&peer->ssl);
1616                 ret = (NULL == peerCert ? -1 : 0);
1617                 SSL_CHECK_FAIL(peer, ret, "Failed to retrieve cert", 1,
1618                                             CA_STATUS_FAILED, MBEDTLS_SSL_ALERT_MSG_NO_CERT);
1619                 uuidPos = memmem(peerCert->subject_raw.p, peerCert->subject_raw.len,
1620                                                  UUID_PREFIX, sizeof(UUID_PREFIX) - 1);
1621
1622                 if (NULL != uuidPos)
1623                 {
1624                     memcpy(uuid, (char*) uuidPos + sizeof(UUID_PREFIX) - 1, UUID_LENGTH * 2 + 4);
1625                     ret = ConvertStrToUuid(uuid, &peer->sep.identity);
1626                     SSL_CHECK_FAIL(peer, ret, "Failed to convert subject", 1,
1627                                           CA_STATUS_FAILED, MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT);
1628                 }
1629                 else
1630                 {
1631                     OIC_LOG(WARNING, NET_SSL_TAG, "uuid not found");
1632                 }
1633
1634                 userIdPos = memmem(peerCert->subject_raw.p, peerCert->subject_raw.len,
1635                                              USERID_PREFIX, sizeof(USERID_PREFIX) - 1);
1636                 if (NULL != userIdPos)
1637                 {
1638                     memcpy(uuid, (char*) userIdPos + sizeof(USERID_PREFIX) - 1, UUID_LENGTH * 2 + 4);
1639                     ret = ConvertStrToUuid(uuid, &peer->sep.userId);
1640                     SSL_CHECK_FAIL(peer, ret, "Failed to convert subject alt name", 1,
1641                                       CA_STATUS_FAILED, MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT);
1642                 }
1643                 else
1644                 {
1645                     OIC_LOG(WARNING, NET_SSL_TAG, "Subject alternative name not found");
1646                 }
1647             }
1648
1649             ca_mutex_unlock(g_sslContextMutex);
1650             OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1651             return CA_STATUS_OK;
1652         }
1653     }
1654
1655     if (MBEDTLS_SSL_HANDSHAKE_OVER == peer->ssl.state)
1656     {
1657         uint8_t decryptBuffer[TLS_MSG_BUF_LEN] = {0};
1658         do
1659         {
1660             ret = mbedtls_ssl_read(&peer->ssl, decryptBuffer, TLS_MSG_BUF_LEN);
1661         } while (MBEDTLS_ERR_SSL_WANT_READ == ret);
1662
1663         if (MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY == ret)
1664         {
1665             OIC_LOG(INFO, NET_SSL_TAG, "Connection was closed gracefully");
1666             SSL_CLOSE_NOTIFY(peer, ret);
1667             RemovePeerFromList(&peer->sep.endpoint);
1668             ca_mutex_unlock(g_sslContextMutex);
1669             return CA_STATUS_OK;
1670         }
1671
1672         if (0 > ret)
1673         {
1674             OIC_LOG_V(ERROR, NET_SSL_TAG, "mbedtls_ssl_read returned -0x%x", -ret);
1675             //SSL_RES(peer, CA_STATUS_FAILED);
1676             RemovePeerFromList(&peer->sep.endpoint);
1677             ca_mutex_unlock(g_sslContextMutex);
1678             return CA_STATUS_FAILED;
1679         }
1680         int adapterIndex = GetAdapterIndex(peer->sep.endpoint.adapter);
1681         if (0 == adapterIndex || adapterIndex == 1)
1682         {
1683             g_caSslContext->adapterCallbacks[adapterIndex].recvCallback(&peer->sep, decryptBuffer, ret);
1684         }
1685         else
1686         {
1687             OIC_LOG(ERROR, NET_SSL_TAG, "Unsuported adapter");
1688             RemovePeerFromList(&peer->sep.endpoint);
1689             ca_mutex_unlock(g_sslContextMutex);
1690             return CA_STATUS_FAILED;
1691         }
1692     }
1693
1694     ca_mutex_unlock(g_sslContextMutex);
1695     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1696     return CA_STATUS_OK;
1697 }
1698
1699 void CAsetSslAdapterCallbacks(CAPacketReceivedCallback recvCallback,
1700                               CAPacketSendCallback sendCallback,
1701                               CATransportAdapter_t type)
1702 {
1703     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1704     VERIFY_NON_NULL_VOID(sendCallback, NET_SSL_TAG, "sendCallback is NULL");
1705     VERIFY_NON_NULL_VOID(recvCallback, NET_SSL_TAG, "recvCallback is NULL");
1706     ca_mutex_lock(g_sslContextMutex);
1707     if (NULL == g_caSslContext)
1708     {
1709         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
1710         ca_mutex_unlock(g_sslContextMutex);
1711         return;
1712     }
1713
1714 //    if (MAX_SUPPORTED_ADAPTERS > type)
1715     {
1716         switch (type)
1717         {
1718             case CA_ADAPTER_IP:
1719                 g_caSslContext->adapterCallbacks[0].recvCallback = recvCallback;
1720                 g_caSslContext->adapterCallbacks[0].sendCallback = sendCallback;
1721                 break;
1722             case CA_ADAPTER_TCP:
1723                 g_caSslContext->adapterCallbacks[1].recvCallback = recvCallback;
1724                 g_caSslContext->adapterCallbacks[1].sendCallback = sendCallback;
1725                 break;
1726             default:
1727                 OIC_LOG_V(ERROR, NET_SSL_TAG, "Unsupported adapter: %d", type);
1728         }
1729     }
1730
1731     ca_mutex_unlock(g_sslContextMutex);
1732     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1733 }
1734
1735 CAResult_t CAsetTlsCipherSuite(const uint32_t cipher)
1736 {
1737     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1738     VERIFY_NON_NULL_RET(g_getCredentialTypesCallback, NET_SSL_TAG, "Param callback is null", CA_STATUS_FAILED);
1739     g_getCredentialTypesCallback(g_caSslContext->cipherFlag);
1740     switch(cipher)
1741     {
1742         case MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA:
1743         {
1744 #ifdef __WITH_TLS__
1745             //todo check that Cred with RSA cert exists
1746             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->clientTlsConf,
1747                                          tlsCipher[ADAPTER_TLS_RSA_WITH_AES_256_CBC_SHA]);
1748             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->serverTlsConf,
1749                                          tlsCipher[ADAPTER_TLS_RSA_WITH_AES_256_CBC_SHA]);
1750 #endif
1751 #ifdef __WITH_DTLS__
1752             //todo check that Cred with RSA cert exists
1753             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->clientDtlsConf,
1754                                          tlsCipher[ADAPTER_TLS_RSA_WITH_AES_256_CBC_SHA]);
1755             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->serverDtlsConf,
1756                                          tlsCipher[ADAPTER_TLS_RSA_WITH_AES_256_CBC_SHA]);
1757 #endif
1758             g_caSslContext->cipher = ADAPTER_TLS_RSA_WITH_AES_256_CBC_SHA;
1759             break;
1760         }
1761         case MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8:
1762         {
1763             if (false == g_caSslContext->cipherFlag[1])
1764             {
1765                 OIC_LOG(ERROR, NET_SSL_TAG, "No Credential for ECC");
1766                 return CA_STATUS_FAILED;
1767             }
1768 #ifdef __WITH_TLS__
1769             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->clientTlsConf,
1770                                          tlsCipher[ADAPTER_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8]);
1771             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->serverTlsConf,
1772                                          tlsCipher[ADAPTER_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8]);
1773 #endif
1774 #ifdef __WITH_DTLS__
1775             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->clientDtlsConf,
1776                                          tlsCipher[ADAPTER_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8]);
1777             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->serverDtlsConf,
1778                                          tlsCipher[ADAPTER_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8]);
1779 #endif
1780             g_caSslContext->cipher = ADAPTER_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8;
1781             break;
1782         }
1783         case MBEDTLS_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA256:
1784         {
1785 #ifdef __WITH_TLS__
1786             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->clientTlsConf,
1787                                          tlsCipher[ADAPTER_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA_256]);
1788             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->serverTlsConf,
1789                                          tlsCipher[ADAPTER_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA_256]);
1790 #endif
1791 #ifdef __WITH_DTLS__
1792             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->clientDtlsConf,
1793                                          tlsCipher[ADAPTER_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA_256]);
1794             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->serverDtlsConf,
1795                                          tlsCipher[ADAPTER_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA_256]);
1796 #endif
1797             g_caSslContext->cipher = ADAPTER_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA_256;
1798             break;
1799         }
1800         case MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256:
1801         {
1802 #if 0 // PIN OTM
1803             if (false == g_caSslContext->cipherFlag[0])
1804             {
1805                 OIC_LOG(ERROR, NET_SSL_TAG, "No Credential for PSK");
1806                 return CA_STATUS_FAILED;
1807             }
1808 #endif
1809 #ifdef __WITH_TLS__
1810             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->clientTlsConf,
1811                                           tlsCipher[ADAPTER_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256]);
1812             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->serverTlsConf,
1813                                           tlsCipher[ADAPTER_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256]);
1814 #endif
1815 #ifdef __WITH_DTLS__
1816             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->clientDtlsConf,
1817                                           tlsCipher[ADAPTER_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256]);
1818             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->serverDtlsConf,
1819                                           tlsCipher[ADAPTER_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256]);
1820 #endif
1821             g_caSslContext->cipher = ADAPTER_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256;
1822             break;
1823         }
1824         default:
1825         {
1826             OIC_LOG(ERROR, NET_SSL_TAG, "Unknown cipher");
1827             return CA_STATUS_FAILED;
1828         }
1829     }
1830     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Selected cipher: 0x%x", cipher);
1831     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1832     return CA_STATUS_OK;
1833 }
1834
1835 CAResult_t CAinitiateSslHandshake(const CAEndpoint_t *endpoint)
1836 {
1837     CAResult_t res = CA_STATUS_OK;
1838     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1839     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG, "Param endpoint is NULL" , CA_STATUS_INVALID_PARAM);
1840     ca_mutex_lock(g_sslContextMutex);
1841     if (NULL == InitiateTlsHandshake(endpoint))
1842     {
1843         OIC_LOG(ERROR, NET_SSL_TAG, "TLS handshake failed");
1844         res = CA_STATUS_FAILED;
1845     }
1846     ca_mutex_unlock(g_sslContextMutex);
1847     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1848     return res;
1849 }
1850 /**
1851  * Expands the secret into blocks of data according
1852  * to the algorithm specified in section 5 of RFC 4346
1853  *
1854  * This function writes upto @p bufLen bytes into the given output buffer @p buf
1855  *
1856  * @param  key    secret key.
1857  * @param  keyLen    secret key length.
1858  * @param  label    A PRF label.
1859  * @param  labelLen     Actual length of @p label.
1860  * @param  random1    Random seed.
1861  * @param  random1Len     Actual length of @p random1 (may be zero).
1862  * @param  random2     Random seed.
1863  * @param  random2Len    Actual length of @p random2 (may be zero).
1864  * @param  buf    Output buffer for generated random data.
1865  * @param  bufLen    Maximum size of @p buf.
1866  *
1867  * @return The actual number of bytes written to @p buf or @c -1 on error.
1868  */
1869
1870 static int pHash (const unsigned char *key, size_t keyLen,
1871      const unsigned char *label, size_t labelLen,
1872      const unsigned char *random1, size_t random1Len,
1873      const unsigned char *random2, size_t random2Len,
1874      unsigned char *buf, size_t bufLen)
1875 {
1876     unsigned char A[RANDOM_LEN] = {0};
1877     unsigned char tmp[RANDOM_LEN] = {0};
1878     size_t dLen;   /* digest length */
1879     size_t len = 0;   /* result length */
1880
1881     VERIFY_NON_NULL_RET(key, NET_SSL_TAG, "key is NULL", -1);
1882     VERIFY_NON_NULL_RET(label, NET_SSL_TAG, "label is NULL", -1);
1883     VERIFY_NON_NULL_RET(random1, NET_SSL_TAG, "random1 is NULL", -1);
1884     VERIFY_NON_NULL_RET(random2, NET_SSL_TAG, "random2 is NULL", -1);
1885     VERIFY_NON_NULL_RET(buf, NET_SSL_TAG, "buf is NULL", -1);
1886
1887     mbedtls_md_context_t hmacA;
1888     mbedtls_md_context_t hmacP;
1889
1890     mbedtls_md_init(&hmacA);
1891     mbedtls_md_init(&hmacP);
1892
1893     CHECK_MBEDTLS_RET(mbedtls_md_setup, &hmacA, mbedtls_md_info_from_type(MBEDTLS_MD_SHA256), 1);
1894     CHECK_MBEDTLS_RET(mbedtls_md_setup, &hmacP, mbedtls_md_info_from_type(MBEDTLS_MD_SHA256), 1);
1895
1896     CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacA, key, keyLen );
1897     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacA, label, labelLen);
1898     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacA, random1, random1Len);
1899     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacA, random2, random2Len);
1900     CHECK_MBEDTLS_RET(mbedtls_md_hmac_finish, &hmacA, A);
1901
1902     dLen = RANDOM_LEN;
1903
1904     CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacP, key, keyLen);
1905
1906     while (len + dLen < bufLen)
1907     {
1908         CHECK_MBEDTLS_RET(mbedtls_md_hmac_reset, &hmacP);
1909         CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacP, key, keyLen);
1910         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, A, dLen);
1911         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, label, labelLen);
1912         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, random1, random1Len);
1913         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, random2, random2Len);
1914
1915         CHECK_MBEDTLS_RET(mbedtls_md_hmac_finish, &hmacP, tmp);
1916
1917         len += RANDOM_LEN;
1918
1919         memcpy(buf, tmp, dLen);
1920         buf += dLen;
1921
1922         CHECK_MBEDTLS_RET(mbedtls_md_hmac_reset, &hmacA);
1923         CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacA, key, keyLen);
1924         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacA, A, dLen);
1925         CHECK_MBEDTLS_RET(mbedtls_md_hmac_finish, &hmacA, A);
1926     }
1927
1928     CHECK_MBEDTLS_RET(mbedtls_md_hmac_reset, &hmacP);
1929     CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacP, key, keyLen);
1930     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, A, dLen);
1931
1932     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, label, labelLen);
1933     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, random1, random1Len);
1934     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, random2, random2Len);
1935     CHECK_MBEDTLS_RET(mbedtls_md_hmac_finish, &hmacP, tmp);
1936
1937     memcpy(buf, tmp, bufLen - len);
1938
1939     mbedtls_md_free(&hmacA);
1940     mbedtls_md_free(&hmacP);
1941     return bufLen;
1942
1943 exit:
1944     mbedtls_md_free(&hmacA);
1945     mbedtls_md_free(&hmacP);
1946     return -1;
1947 }
1948
1949 CAResult_t CAsslGenerateOwnerPsk(const CAEndpoint_t *endpoint,
1950                             const uint8_t* label, const size_t labelLen,
1951                             const uint8_t* rsrcServerDeviceId, const size_t rsrcServerDeviceIdLen,
1952                             const uint8_t* provServerDeviceId, const size_t provServerDeviceIdLen,
1953                             uint8_t* ownerPsk, const size_t ownerPskSize)
1954 {
1955     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1956     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG, "endpoint is NULL", CA_STATUS_INVALID_PARAM);
1957     VERIFY_NON_NULL_RET(label, NET_SSL_TAG, "label is NULL", CA_STATUS_INVALID_PARAM);
1958     VERIFY_NON_NULL_RET(rsrcServerDeviceId, NET_SSL_TAG, "rsrcId is NULL", CA_STATUS_INVALID_PARAM);
1959     VERIFY_NON_NULL_RET(provServerDeviceId, NET_SSL_TAG, "provId is NULL", CA_STATUS_INVALID_PARAM);
1960     VERIFY_NON_NULL_RET(ownerPsk, NET_SSL_TAG, "ownerPSK is NULL", CA_STATUS_INVALID_PARAM);
1961
1962     ca_mutex_lock(g_sslContextMutex);
1963     if (NULL == g_caSslContext)
1964     {
1965         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
1966         ca_mutex_unlock(g_sslContextMutex);
1967         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1968         return CA_STATUS_FAILED;
1969     }
1970     SslEndPoint_t * tep = GetSslPeer(endpoint);
1971     if (NULL == tep)
1972     {
1973         OIC_LOG(ERROR, NET_SSL_TAG, "Session does not exist");
1974         ca_mutex_unlock(g_sslContextMutex);
1975         return CA_STATUS_FAILED;
1976     }
1977
1978     uint8_t keyblock[KEY_BLOCK_LEN] = {0};
1979     // "key expansion"
1980     uint8_t lab[] = {0x6b, 0x65, 0x79, 0x20, 0x65, 0x78, 0x70, 0x61, 0x6e, 0x73, 0x69, 0x6f, 0x6e};
1981     int ret = pHash(tep->master, sizeof(tep->master), lab, sizeof(lab),
1982                     (tep->random) + RANDOM_LEN, RANDOM_LEN, tep->random, RANDOM_LEN,
1983                     keyblock, KEY_BLOCK_LEN);
1984     if (-1 == ret)
1985     {
1986         OIC_LOG(ERROR, NET_SSL_TAG, "PSK not generated");
1987         ca_mutex_unlock(g_sslContextMutex);
1988         return CA_STATUS_FAILED;
1989     }
1990     ret = pHash(keyblock, sizeof(keyblock), label, labelLen,
1991                 rsrcServerDeviceId, rsrcServerDeviceIdLen,
1992                 provServerDeviceId, provServerDeviceIdLen,
1993                 ownerPsk, ownerPskSize);
1994     if (-1 == ret)
1995     {
1996         OIC_LOG(ERROR, NET_SSL_TAG, "PSK not generated");
1997         ca_mutex_unlock(g_sslContextMutex);
1998         return CA_STATUS_FAILED;
1999     }
2000
2001     ca_mutex_unlock(g_sslContextMutex);
2002
2003     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2004     return CA_STATUS_OK;
2005 }