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 #ifdef _ENABLE_MULTIPLE_OWNER_
 770 /**
 771  * Gets CA secure endpoint info corresponding for endpoint.
 772  *
 773  * @param[in]  peer    remote address
 774  *
 775  * @return  CASecureEndpoint or NULL
 776  */
 777 const CASecureEndpoint_t *GetCASecureEndpointData(const CAEndpoint_t* peer)
 778 {
 779     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 780
 781     // TODO: Added as workaround, need to debug
 782     ca_mutex_unlock(g_sslContextMutex);
 783
 784     ca_mutex_lock(g_sslContextMutex);
 785     if (NULL == g_caSslContext)
 786     {
 787         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
 788         ca_mutex_unlock(g_sslContextMutex);
 789         return NULL;
 790     }
 791
 792     SslEndPoint_t* sslPeer = GetSslPeer(peer);
 793     if(sslPeer)
 794     {
 795         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 796         ca_mutex_unlock(g_sslContextMutex);
 797         return &sslPeer->sep;
 798     }
 799
 800     OIC_LOG(DEBUG, NET_SSL_TAG, "Return NULL");
 801     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 802     ca_mutex_unlock(g_sslContextMutex);
 803     return NULL;
 804 }
 805 #endif
 806
 807 /**
 808  * Deletes cached message.
 809  *
 810  * @param[in]  msg    message
 811  */
 812 static void DeleteCacheMessage(SslCacheMessage_t * msg)
 813 {
 814     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 815     VERIFY_NON_NULL_VOID(msg, NET_SSL_TAG, "msg");
 816
 817     OICFree(msg->data);
 818     OICFree(msg);
 819
 820     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 821 }
 822 /**
 823  * Deletes cached message list.
 824  *
 825  * @param[in] cacheList  list of cached messages
 826  */
 827 static void DeleteCacheList(u_arraylist_t * cacheList)
 828 {
 829     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 830     VERIFY_NON_NULL_VOID(cacheList, NET_SSL_TAG, "cacheList");
 831     uint32_t listIndex = 0;
 832     uint32_t listLength = 0;
 833
 834     listLength = u_arraylist_length(cacheList);
 835     for (listIndex = 0; listIndex < listLength; listIndex++)
 836     {
 837         SslCacheMessage_t * msg = (SslCacheMessage_t *) u_arraylist_get(cacheList, listIndex);
 838         if (NULL != msg)
 839         {
 840             DeleteCacheMessage(msg);
 841         }
 842     }
 843     u_arraylist_free(&cacheList);
 844
 845     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 846 }
 847 /**
 848  * Deletes endpoint with session.
 849  *
 850  * @param[in]  tep    endpoint with session info
 851  */
 852 static void DeleteSslEndPoint(SslEndPoint_t * tep)
 853 {
 854     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 855     VERIFY_NON_NULL_VOID(tep, NET_SSL_TAG, "tep");
 856
 857     mbedtls_ssl_free(&tep->ssl);
 858 #ifdef __WITH_DTLS__
 859     mbedtls_ssl_cookie_free(&tep->cookieCtx);
 860 #endif
 861     DeleteCacheList(tep->cacheList);
 862     OICFree(tep);
 863     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 864 }
 865 /**
 866  * Removes endpoint session from list.
 867  *
 868  * @param[in]  endpoint    remote address
 869  */
 870 static void RemovePeerFromList(CAEndpoint_t * endpoint)
 871 {
 872     uint32_t listLength = u_arraylist_length(g_caSslContext->peerList);
 873     VERIFY_NON_NULL_VOID(endpoint, NET_SSL_TAG, "endpoint");
 874     for (uint32_t listIndex = 0; listIndex < listLength; listIndex++)
 875     {
 876         SslEndPoint_t * tep = (SslEndPoint_t *)u_arraylist_get(g_caSslContext->peerList,listIndex);
 877         if (NULL == tep)
 878         {
 879             continue;
 880         }
 881         if(0 == strncmp(endpoint->addr, tep->sep.endpoint.addr, MAX_ADDR_STR_SIZE_CA)
 882                 && (endpoint->port == tep->sep.endpoint.port))
 883         {
 884             u_arraylist_remove(g_caSslContext->peerList, listIndex);
 885             DeleteSslEndPoint(tep);
 886             return;
 887         }
 888     }
 889 }
 890 /**
 891  * Deletes session list.
 892  */
 893 static void DeletePeerList()
 894 {
 895     uint32_t listLength = u_arraylist_length(g_caSslContext->peerList);
 896     for (uint32_t listIndex = 0; listIndex < listLength; listIndex++)
 897     {
 898         SslEndPoint_t * tep = (SslEndPoint_t *)u_arraylist_get(g_caSslContext->peerList,listIndex);
 899         if (NULL == tep)
 900         {
 901             continue;
 902         }
 903         DeleteSslEndPoint(tep);
 904     }
 905     u_arraylist_free(&g_caSslContext->peerList);
 906 }
 907
 908 CAResult_t CAcloseSslConnection(const CAEndpoint_t *endpoint)
 909 {
 910     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 911     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG, "Param endpoint is NULL" , CA_STATUS_INVALID_PARAM);
 912
 913     ca_mutex_lock(g_sslContextMutex);
 914     if (NULL == g_caSslContext)
 915     {
 916         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
 917         ca_mutex_unlock(g_sslContextMutex);
 918         return CA_STATUS_FAILED;
 919     }
 920     SslEndPoint_t * tep = GetSslPeer(endpoint);
 921     if (NULL == tep)
 922     {
 923         OIC_LOG(ERROR, NET_SSL_TAG, "Session does not exist");
 924         ca_mutex_unlock(g_sslContextMutex);
 925         return CA_STATUS_FAILED;
 926     }
 927     /* No error checking, the connection might be closed already */
 928     int ret = 0;
 929     do
 930     {
 931         ret = mbedtls_ssl_close_notify(&tep->ssl);
 932     }
 933     while (MBEDTLS_ERR_SSL_WANT_WRITE == ret);
 934
 935     RemovePeerFromList(&tep->sep.endpoint);
 936     ca_mutex_unlock(g_sslContextMutex);
 937
 938     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 939     return CA_STATUS_OK;
 940 }
 941 /**
 942  * Creates session for endpoint.
 943  *
 944  * @param[in]  endpoint    remote address
 945  * @param[in]  config    mbedTLS configuration info
 946  *
 947  * @return  TLS endpoint or NULL
 948  */
 949 static SslEndPoint_t * NewSslEndPoint(const CAEndpoint_t * endpoint, mbedtls_ssl_config * config)
 950 {
 951     SslEndPoint_t * tep = NULL;
 952     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 953     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG, "endpoint", NULL);
 954     VERIFY_NON_NULL_RET(config, NET_SSL_TAG, "config", NULL);
 955
 956     tep = (SslEndPoint_t *) OICCalloc(1, sizeof (SslEndPoint_t));
 957     if (NULL == tep)
 958     {
 959         OIC_LOG(ERROR, NET_SSL_TAG, "Malloc failed!");
 960         return NULL;
 961     }
 962
 963     tep->sep.endpoint = *endpoint;
 964     tep->sep.endpoint.flags = (CATransportFlags_t)(tep->sep.endpoint.flags | CA_SECURE);
 965
 966     if(0 != mbedtls_ssl_setup(&tep->ssl, config))
 967     {
 968         OIC_LOG(ERROR, NET_SSL_TAG, "Setup failed");
 969         OICFree(tep);
 970         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 971         return NULL;
 972     }
 973
 974     mbedtls_ssl_set_bio(&tep->ssl, tep, SendCallBack, RecvCallBack, NULL);
 975     if (MBEDTLS_SSL_TRANSPORT_DATAGRAM == config->transport)
 976     {
 977         mbedtls_ssl_set_timer_cb(&tep->ssl, &g_caSslContext->timer,
 978                                   mbedtls_timing_set_delay, mbedtls_timing_get_delay);
 979         if (MBEDTLS_SSL_IS_SERVER == config->endpoint)
 980         {
 981             if (0 != mbedtls_ssl_cookie_setup(&tep->cookieCtx, mbedtls_ctr_drbg_random,
 982                                               &g_caSslContext->rnd))
 983             {
 984                 OIC_LOG(ERROR, NET_SSL_TAG, "Cookie setup failed!");
 985                 OICFree(tep);
 986                 OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 987                 return NULL;
 988             }
 989             mbedtls_ssl_conf_dtls_cookies(config, mbedtls_ssl_cookie_write, mbedtls_ssl_cookie_check,
 990                                           &tep->cookieCtx);
 991             if (0 != mbedtls_ssl_set_client_transport_id(&tep->ssl,
 992                                     (const unsigned char *) endpoint->addr, sizeof(endpoint->addr)))
 993             {
 994                 OIC_LOG(ERROR, NET_SSL_TAG, "Transport id setup failed!");
 995                 OICFree(tep);
 996                 OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 997                 return NULL;
 998             }
 999         }
1000     }
1001     tep->cacheList = u_arraylist_create();
1002     if (NULL == tep->cacheList)
1003     {
1004         OIC_LOG(ERROR, NET_SSL_TAG, "cacheList initialization failed!");
1005         mbedtls_ssl_free(&tep->ssl);
1006         OICFree(tep);
1007         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1008         return NULL;
1009     }
1010     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1011     return tep;
1012 }
1013 /**
1014  * Initializes PSK identity.
1015  *
1016  * @param[out]  config    client/server config to be updated
1017  *
1018  * @return  0 on success or -1 on error
1019  */
1020 static int InitPskIdentity(mbedtls_ssl_config * config)
1021 {
1022     uint8_t idBuf[UUID_LENGTH] = {0};
1023     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1024     VERIFY_NON_NULL_RET(config, NET_SSL_TAG, "Param config is NULL" , -1);
1025
1026     if (0 > g_getCredentialsCallback(CA_DTLS_PSK_IDENTITY, NULL, 0, idBuf, UUID_LENGTH))
1027     {
1028         OIC_LOG(ERROR, NET_SSL_TAG, "Identity not found");
1029         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1030         return -1;
1031     }
1032     if (0 != mbedtls_ssl_conf_psk(config, idBuf, 0, idBuf, UUID_LENGTH))
1033     {
1034         OIC_LOG(ERROR, NET_SSL_TAG, "Identity initialization failed!");
1035         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1036         return -1;
1037     }
1038     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1039     return 0;
1040 }
1041 static void SetupCipher(mbedtls_ssl_config * config, CATransportAdapter_t adapter)
1042 {
1043     int index = 0;
1044     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1045     if (NULL == g_getCredentialTypesCallback)
1046     {
1047         OIC_LOG(ERROR, NET_SSL_TAG, "Param callback is null");
1048         return;
1049     }
1050
1051     g_getCredentialTypesCallback(g_caSslContext->cipherFlag);
1052     // Retrieve the PSK credential from SRM
1053     // PIN OTM if (true == g_caSslContext->cipherFlag[0] && 0 != InitPskIdentity(config))
1054     if (0 != InitPskIdentity(config))
1055     {
1056         OIC_LOG(ERROR, NET_SSL_TAG, "PSK identity initialization failed!");
1057     }
1058
1059     // Retrieve the ECC credential from SRM
1060     if (true == g_caSslContext->cipherFlag[1] || ADAPTER_TLS_RSA_WITH_AES_256_CBC_SHA == g_caSslContext->cipher)
1061     {
1062         int ret = InitPKIX(adapter);
1063         if (0 != ret)
1064         {
1065             OIC_LOG(ERROR, NET_SSL_TAG, "Failed to init X.509");
1066         }
1067     }
1068
1069     memset(g_cipherSuitesList, 0, sizeof(g_cipherSuitesList));
1070     if (ADAPTER_CIPHER_MAX != g_caSslContext->cipher)
1071     {
1072         g_cipherSuitesList[index] = tlsCipher[g_caSslContext->cipher][0];
1073         index ++;
1074     }
1075     if (true == g_caSslContext->cipherFlag[1])
1076     {
1077         g_cipherSuitesList[index] = MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8;
1078         index ++;
1079     }
1080     if (true == g_caSslContext->cipherFlag[0])
1081     {
1082        g_cipherSuitesList[index] = MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256;
1083     }
1084
1085     mbedtls_ssl_conf_ciphersuites(config, g_cipherSuitesList);
1086
1087     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1088 }
1089 /**
1090  * Initiate TLS handshake with endpoint.
1091  *
1092  * @param[in]  endpoint    remote address
1093  *
1094  * @return  TLS endpoint or NULL
1095  */
1096 static SslEndPoint_t * InitiateTlsHandshake(const CAEndpoint_t *endpoint)
1097 {
1098     int ret = 0;
1099     SslEndPoint_t * tep = NULL;
1100
1101     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1102     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG, "Param endpoint is NULL" , NULL);
1103
1104
1105     mbedtls_ssl_config * config = (endpoint->adapter == CA_ADAPTER_IP ?
1106                                    &g_caSslContext->clientDtlsConf : &g_caSslContext->clientTlsConf);
1107     tep = NewSslEndPoint(endpoint, config);
1108     if (NULL == tep)
1109     {
1110         OIC_LOG(ERROR, NET_SSL_TAG, "Malloc failed!");
1111         return NULL;
1112     }
1113
1114     //Load allowed SVR suites from SVR DB
1115     SetupCipher(config, endpoint->adapter);
1116
1117     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Add %s:%d", tep->sep.endpoint.addr, tep->sep.endpoint.port);
1118     ret = u_arraylist_add(g_caSslContext->peerList, (void *) tep);
1119     if (!ret)
1120     {
1121         OIC_LOG(ERROR, NET_SSL_TAG, "u_arraylist_add failed!");
1122         DeleteSslEndPoint(tep);
1123         return NULL;
1124     }
1125
1126     while (MBEDTLS_SSL_HANDSHAKE_OVER > tep->ssl.state)
1127     {
1128         ret = mbedtls_ssl_handshake_step(&tep->ssl);
1129         if (MBEDTLS_ERR_SSL_CONN_EOF == ret)
1130         {
1131             break;
1132         }
1133         SSL_CHECK_FAIL(tep, ret, "Handshake error", 0, NULL, MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE);
1134     }
1135     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1136     return tep;
1137 }
1138
1139 void CAdeinitSslAdapter()
1140 {
1141     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1142
1143     VERIFY_NON_NULL_VOID(g_caSslContext, NET_SSL_TAG, "context is NULL");
1144     VERIFY_NON_NULL_VOID(g_sslContextMutex, NET_SSL_TAG, "context mutex is NULL");
1145
1146     //Lock tlsContext mutex
1147     ca_mutex_lock(g_sslContextMutex);
1148
1149     // Clear all lists
1150     DeletePeerList();
1151
1152     // De-initialize mbedTLS
1153     mbedtls_x509_crt_free(&g_caSslContext->crt);
1154     mbedtls_pk_free(&g_caSslContext->pkey);
1155 #ifdef __WITH_TLS__
1156     mbedtls_ssl_config_free(&g_caSslContext->clientTlsConf);
1157     mbedtls_ssl_config_free(&g_caSslContext->serverTlsConf);
1158 #endif // __WITH_TLS__
1159 #ifdef __WITH_DTLS__
1160     mbedtls_ssl_config_free(&g_caSslContext->clientDtlsConf);
1161     mbedtls_ssl_config_free(&g_caSslContext->serverDtlsConf);
1162 #endif // __WITH_DTLS__
1163     mbedtls_ctr_drbg_free(&g_caSslContext->rnd);
1164     mbedtls_entropy_free(&g_caSslContext->entropy);
1165
1166     // De-initialize tls Context
1167     OICFree(g_caSslContext);
1168     g_caSslContext = NULL;
1169
1170     // Unlock tlsContext mutex and de-initialize it
1171     ca_mutex_unlock(g_sslContextMutex);
1172     ca_mutex_free(g_sslContextMutex);
1173     g_sslContextMutex = NULL;
1174
1175     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s ", __func__);
1176 }
1177
1178 static int InitConfig(mbedtls_ssl_config * conf, int transport, int mode)
1179 {
1180     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1181     VERIFY_NON_NULL_RET(conf, NET_SSL_TAG, "Param conf is NULL" , -1);
1182     mbedtls_ssl_config_init(conf);
1183     if (mbedtls_ssl_config_defaults(conf, mode, transport, MBEDTLS_SSL_PRESET_DEFAULT) != 0)
1184     {
1185         OIC_LOG(ERROR, NET_SSL_TAG, "Config initialization failed!");
1186         return -1;
1187     }
1188
1189     mbedtls_ssl_conf_psk_cb(conf, GetPskCredentialsCallback, NULL);
1190     mbedtls_ssl_conf_rng(conf, mbedtls_ctr_drbg_random, &g_caSslContext->rnd);
1191     mbedtls_ssl_conf_curves(conf, curve[ADAPTER_CURVE_SECP256R1]);
1192     mbedtls_ssl_conf_min_version(conf, MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3);
1193     mbedtls_ssl_conf_renegotiation(conf, MBEDTLS_SSL_RENEGOTIATION_DISABLED);
1194     mbedtls_ssl_conf_authmode(conf, MBEDTLS_SSL_VERIFY_REQUIRED);
1195
1196 #ifndef NDEBUG
1197     mbedtls_ssl_conf_dbg(conf, DebugSsl, NULL);
1198     mbedtls_debug_set_threshold(MBED_TLS_DEBUG_LEVEL);
1199 #endif
1200     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1201     return 0;
1202 }
1203
1204 CAResult_t CAinitSslAdapter()
1205 {
1206     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1207     // Initialize mutex for tlsContext
1208     if (NULL == g_sslContextMutex)
1209     {
1210         g_sslContextMutex = ca_mutex_new();
1211         VERIFY_NON_NULL_RET(g_sslContextMutex, NET_SSL_TAG, "malloc failed", CA_MEMORY_ALLOC_FAILED);
1212     }
1213     else
1214     {
1215         OIC_LOG(INFO, NET_SSL_TAG, "Done already!");
1216         return CA_STATUS_OK;
1217     }
1218
1219     // Lock tlsContext mutex and create tlsContext
1220     ca_mutex_lock(g_sslContextMutex);
1221     g_caSslContext = (SslContext_t *)OICCalloc(1, sizeof(SslContext_t));
1222
1223     if (NULL == g_caSslContext)
1224     {
1225         OIC_LOG(ERROR, NET_SSL_TAG, "Context malloc failed");
1226         ca_mutex_unlock(g_sslContextMutex);
1227         ca_mutex_free(g_sslContextMutex);
1228         g_sslContextMutex = NULL;
1229         return CA_MEMORY_ALLOC_FAILED;
1230     }
1231
1232     // Create peer list
1233     g_caSslContext->peerList = u_arraylist_create();
1234
1235     if(NULL == g_caSslContext->peerList)
1236     {
1237         OIC_LOG(ERROR, NET_SSL_TAG, "peerList initialization failed!");
1238         OICFree(g_caSslContext);
1239         g_caSslContext = NULL;
1240         ca_mutex_unlock(g_sslContextMutex);
1241         ca_mutex_free(g_sslContextMutex);
1242         g_sslContextMutex = NULL;
1243         return CA_STATUS_FAILED;
1244     }
1245
1246     /* Initialize TLS library
1247      */
1248 #ifndef NDEBUG
1249     char version[MBED_TLS_VERSION_LEN];
1250     mbedtls_version_get_string(version);
1251     OIC_LOG_V(INFO, NET_SSL_TAG, "mbed TLS version: %s", version);
1252 #endif
1253
1254     /* Entropy settings
1255      */
1256     mbedtls_entropy_init(&g_caSslContext->entropy);
1257     mbedtls_ctr_drbg_init(&g_caSslContext->rnd);
1258
1259 #ifdef __unix__
1260     unsigned char seed[sizeof(SEED)] = {0};
1261     int urandomFd = -2;
1262     urandomFd = open("/dev/urandom", O_RDONLY);
1263     if(urandomFd == -1)
1264     {
1265         OIC_LOG(ERROR, NET_SSL_TAG, "Fails open /dev/urandom!");
1266         ca_mutex_unlock(g_sslContextMutex);
1267         CAdeinitSslAdapter();
1268         return CA_STATUS_FAILED;
1269     }
1270     if(0 > read(urandomFd, seed, sizeof(seed)))
1271     {
1272         OIC_LOG(ERROR, NET_SSL_TAG, "Fails read from /dev/urandom!");
1273         close(urandomFd);
1274         ca_mutex_unlock(g_sslContextMutex);
1275         CAdeinitSslAdapter();
1276         return CA_STATUS_FAILED;
1277     }
1278     close(urandomFd);
1279
1280 #else
1281     unsigned char * seed = (unsigned char*) SEED;
1282 #endif
1283     if(0 != mbedtls_ctr_drbg_seed(&g_caSslContext->rnd, mbedtls_entropy_func,
1284                                   &g_caSslContext->entropy, seed, sizeof(SEED)))
1285     {
1286         OIC_LOG(ERROR, NET_SSL_TAG, "Seed initialization failed!");
1287         ca_mutex_unlock(g_sslContextMutex);
1288         CAdeinitSslAdapter();
1289         return CA_STATUS_FAILED;
1290     }
1291     mbedtls_ctr_drbg_set_prediction_resistance(&g_caSslContext->rnd, MBEDTLS_CTR_DRBG_PR_OFF);
1292
1293 #ifdef __WITH_TLS__
1294     if (0 != InitConfig(&g_caSslContext->clientTlsConf,
1295                         MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_IS_CLIENT))
1296     {
1297         OIC_LOG(ERROR, NET_SSL_TAG, "Client config initialization failed!");
1298         ca_mutex_unlock(g_sslContextMutex);
1299         CAdeinitSslAdapter();
1300         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1301         return CA_STATUS_FAILED;
1302     }
1303
1304     if (0 != InitConfig(&g_caSslContext->serverTlsConf,
1305                         MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_IS_SERVER))
1306     {
1307         OIC_LOG(ERROR, NET_SSL_TAG, "Server config initialization failed!");
1308         ca_mutex_unlock(g_sslContextMutex);
1309         CAdeinitSslAdapter();
1310         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1311         return CA_STATUS_FAILED;
1312     }
1313 #endif // __WITH_TLS__
1314 #ifdef __WITH_DTLS__
1315     if (0 != InitConfig(&g_caSslContext->clientDtlsConf,
1316                         MBEDTLS_SSL_TRANSPORT_DATAGRAM, MBEDTLS_SSL_IS_CLIENT))
1317     {
1318         OIC_LOG(ERROR, NET_SSL_TAG, "Client config initialization failed!");
1319         ca_mutex_unlock(g_sslContextMutex);
1320         CAdeinitSslAdapter();
1321         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1322         return CA_STATUS_FAILED;
1323     }
1324
1325     if (0 != InitConfig(&g_caSslContext->serverDtlsConf,
1326                         MBEDTLS_SSL_TRANSPORT_DATAGRAM, MBEDTLS_SSL_IS_SERVER))
1327     {
1328         OIC_LOG(ERROR, NET_SSL_TAG, "Server config initialization failed!");
1329         ca_mutex_unlock(g_sslContextMutex);
1330         CAdeinitSslAdapter();
1331         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1332         return CA_STATUS_FAILED;
1333     }
1334 #endif // __WITH_DTLS__
1335
1336     // set default cipher
1337     g_caSslContext->cipher = ADAPTER_CIPHER_MAX;
1338
1339     // init X.509
1340     mbedtls_x509_crt_init(&g_caSslContext->ca);
1341     mbedtls_x509_crt_init(&g_caSslContext->crt);
1342     mbedtls_pk_init(&g_caSslContext->pkey);
1343     mbedtls_x509_crl_init(&g_caSslContext->crl);
1344
1345     ca_mutex_unlock(g_sslContextMutex);
1346
1347     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1348     return CA_STATUS_OK;
1349 }
1350
1351 SslCacheMessage_t *  NewCacheMessage(uint8_t * data, size_t dataLen)
1352 {
1353     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1354     VERIFY_NON_NULL_RET(data, NET_SSL_TAG, "Param data is NULL" , NULL);
1355     if (0 == dataLen)
1356     {
1357         OIC_LOG(ERROR, NET_SSL_TAG, "dataLen is equal to zero");
1358         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1359         return NULL;
1360     }
1361     SslCacheMessage_t * message = (SslCacheMessage_t *) OICCalloc(1, sizeof(SslCacheMessage_t));
1362     if (NULL == message)
1363     {
1364         OIC_LOG(ERROR, NET_SSL_TAG, "calloc failed!");
1365         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1366         return NULL;
1367     }
1368
1369     message->data = (uint8_t *)OICCalloc(dataLen, sizeof(uint8_t));
1370     if (NULL == message->data)
1371     {
1372         OIC_LOG(ERROR, NET_SSL_TAG, "calloc failed!");
1373         OICFree(message);
1374         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1375         return NULL;
1376     }
1377     memcpy(message->data, data, dataLen);
1378     message->len = dataLen;
1379     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1380     return message;
1381 }
1382
1383 /* Send data via TLS connection.
1384  */
1385 CAResult_t CAencryptSsl(const CAEndpoint_t *endpoint,
1386                         void *data, uint32_t dataLen)
1387 {
1388     int ret = 0;
1389
1390     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s ", __func__);
1391
1392     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG,"Remote address is NULL", CA_STATUS_INVALID_PARAM);
1393     VERIFY_NON_NULL_RET(data, NET_SSL_TAG, "Data is NULL", CA_STATUS_INVALID_PARAM);
1394     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Port %d", endpoint->port);
1395
1396     if (0 == dataLen)
1397     {
1398         OIC_LOG_V(ERROR, NET_SSL_TAG, "dataLen is zero [%d]", dataLen);
1399         return CA_STATUS_FAILED;
1400     }
1401
1402     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Data to be encrypted dataLen [%d]", dataLen);
1403
1404     ca_mutex_lock(g_sslContextMutex);
1405     if(NULL == g_caSslContext)
1406     {
1407         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
1408         ca_mutex_unlock(g_sslContextMutex);
1409         return CA_STATUS_FAILED;
1410     }
1411
1412     SslEndPoint_t * tep = GetSslPeer(endpoint);
1413     if (NULL == tep)
1414     {
1415         tep = InitiateTlsHandshake(endpoint);
1416     }
1417     if (NULL == tep)
1418     {
1419         OIC_LOG(ERROR, NET_SSL_TAG, "TLS handshake failed");
1420         ca_mutex_unlock(g_sslContextMutex);
1421         return CA_STATUS_FAILED;
1422     }
1423
1424     if (MBEDTLS_SSL_HANDSHAKE_OVER == tep->ssl.state)
1425     {
1426         ret = mbedtls_ssl_write(&tep->ssl, (unsigned char *) data, dataLen);
1427
1428         if(ret < 0)
1429         {
1430             OIC_LOG_V(ERROR, NET_SSL_TAG, "mbedTLS write returned %d", ret);
1431             RemovePeerFromList(&tep->sep.endpoint);
1432             ca_mutex_unlock(g_sslContextMutex);
1433             return CA_STATUS_FAILED;
1434         }
1435     }
1436     else
1437     {
1438         SslCacheMessage_t * msg = NewCacheMessage((uint8_t*) data, dataLen);
1439         if (NULL == msg || !u_arraylist_add(tep->cacheList, (void *) msg))
1440         {
1441             OIC_LOG(ERROR, NET_SSL_TAG, "u_arraylist_add failed!");
1442             ca_mutex_unlock(g_sslContextMutex);
1443             return CA_STATUS_FAILED;
1444         }
1445     }
1446
1447     ca_mutex_unlock(g_sslContextMutex);
1448
1449     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1450     return CA_STATUS_OK;
1451 }
1452 /**
1453  * Sends cached messages via TLS connection.
1454  *
1455  * @param[in]  tep    remote address with session info
1456  */
1457 static void SendCacheMessages(SslEndPoint_t * tep)
1458 {
1459     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1460     VERIFY_NON_NULL_VOID(tep, NET_SSL_TAG, "Param tep is NULL");
1461
1462     uint32_t listIndex = 0;
1463     uint32_t listLength = 0;
1464     listLength = u_arraylist_length(tep->cacheList);
1465     for (listIndex = 0; listIndex < listLength;)
1466     {
1467         int ret = 0;
1468         SslCacheMessage_t * msg = (SslCacheMessage_t *) u_arraylist_get(tep->cacheList, listIndex);
1469         if (NULL != msg && NULL != msg->data && 0 != msg->len)
1470         {
1471             do
1472             {
1473                 ret = mbedtls_ssl_write(&tep->ssl, (unsigned char *) msg->data, msg->len);
1474             }
1475             while(MBEDTLS_ERR_SSL_WANT_WRITE == ret);
1476
1477             if(ret < 0)
1478             {
1479                 OIC_LOG_V(ERROR, NET_SSL_TAG,"mbedTLS write returned %d", ret );
1480             }
1481             if (u_arraylist_remove(tep->cacheList, listIndex))
1482             {
1483                 DeleteCacheMessage(msg);
1484                 // Reduce list length by 1 as we removed one element.
1485                 listLength--;
1486             }
1487             else
1488             {
1489                 OIC_LOG(ERROR, NET_SSL_TAG, "u_arraylist_remove failed.");
1490                 break;
1491             }
1492         }
1493         else
1494         {
1495             // Move to the next element
1496             ++listIndex;
1497         }
1498     }
1499     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1500 }
1501
1502 void CAsetSslHandshakeCallback(CAErrorCallback tlsHandshakeCallback)
1503 {
1504     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1505     g_sslCallback = tlsHandshakeCallback;
1506     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1507 }
1508 // TODO move ConvertStrToUuid function to common module
1509 /*
1510  * Converts string UUID to CARemoteId_t
1511  *
1512  * @param strUuid Device UUID in string format
1513  * @param uuid converted UUID in CARemoteId_t format
1514  *
1515  * @return 0 for success.
1516  * */
1517 static int ConvertStrToUuid(const char* strUuid, CARemoteId_t* uuid)
1518 {
1519     if(NULL == strUuid || NULL == uuid)
1520     {
1521         OIC_LOG(ERROR, NET_SSL_TAG, "ConvertStrToUuid : Invalid param");
1522         return -1;
1523     }
1524
1525     size_t urnIdx = 0;
1526     size_t uuidIdx = 0;
1527     size_t strUuidLen = 0;
1528     char convertedUuid[UUID_LENGTH * 2] = {0};
1529
1530     strUuidLen = strlen(strUuid);
1531     if(0 == strUuidLen)
1532     {
1533         OIC_LOG(INFO, NET_SSL_TAG, "The empty string detected, The UUID will be converted to "\
1534                            "\"00000000-0000-0000-0000-000000000000\"");
1535     }
1536     else if(UUID_LENGTH * 2 + 4 == strUuidLen)
1537     {
1538         for(uuidIdx=0, urnIdx=0; uuidIdx < UUID_LENGTH ; uuidIdx++, urnIdx+=2)
1539         {
1540             if(*(strUuid + urnIdx) == '-')
1541             {
1542                 urnIdx++;
1543             }
1544             sscanf(strUuid + urnIdx, "%2hhx", &convertedUuid[uuidIdx]);
1545         }
1546     }
1547     else
1548     {
1549         OIC_LOG(ERROR, NET_SSL_TAG, "Invalid string uuid format");
1550         return -1;
1551     }
1552
1553     memcpy(uuid->id, convertedUuid, UUID_LENGTH);
1554     uuid->id_length = UUID_LENGTH;
1555     return 0;
1556 }
1557
1558 /* Read data from TLS connection
1559  */
1560 CAResult_t CAdecryptSsl(const CASecureEndpoint_t *sep, uint8_t *data, uint32_t dataLen)
1561 {
1562     int ret = 0;
1563     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1564     VERIFY_NON_NULL_RET(sep, NET_SSL_TAG, "endpoint is NULL" , CA_STATUS_INVALID_PARAM);
1565     VERIFY_NON_NULL_RET(data, NET_SSL_TAG, "Param data is NULL" , CA_STATUS_INVALID_PARAM);
1566
1567     ca_mutex_lock(g_sslContextMutex);
1568     if (NULL == g_caSslContext)
1569     {
1570         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
1571         ca_mutex_unlock(g_sslContextMutex);
1572         return CA_STATUS_FAILED;
1573     }
1574
1575
1576     SslEndPoint_t * peer = GetSslPeer(&sep->endpoint);
1577     if (NULL == peer)
1578     {
1579         mbedtls_ssl_config * config = (sep->endpoint.adapter == CA_ADAPTER_IP ?
1580                                    &g_caSslContext->serverDtlsConf : &g_caSslContext->serverTlsConf);
1581         peer = NewSslEndPoint(&sep->endpoint, config);
1582         if (NULL == peer)
1583         {
1584             OIC_LOG(ERROR, NET_SSL_TAG, "Malloc failed!");
1585             ca_mutex_unlock(g_sslContextMutex);
1586             return CA_STATUS_FAILED;
1587         }
1588         //Load allowed TLS suites from SVR DB
1589         SetupCipher(config, sep->endpoint.adapter);
1590
1591         ret = u_arraylist_add(g_caSslContext->peerList, (void *) peer);
1592         if (!ret)
1593         {
1594             OIC_LOG(ERROR, NET_SSL_TAG, "u_arraylist_add failed!");
1595             OICFree(peer);
1596             ca_mutex_unlock(g_sslContextMutex);
1597             return CA_STATUS_FAILED;
1598         }
1599     }
1600
1601     peer->recBuf.buff = data;
1602     peer->recBuf.len = dataLen;
1603     peer->recBuf.loaded = 0;
1604
1605     while (MBEDTLS_SSL_HANDSHAKE_OVER != peer->ssl.state)
1606     {
1607         ret = mbedtls_ssl_handshake_step(&peer->ssl);
1608         if (MBEDTLS_ERR_SSL_CONN_EOF == ret)
1609         {
1610             break;
1611         }
1612
1613         if (MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED == ret)
1614         {
1615             OIC_LOG(DEBUG, NET_SSL_TAG, "Hello verification requested");
1616             mbedtls_ssl_session_reset(&peer->ssl);
1617             mbedtls_ssl_set_client_transport_id(&peer->ssl,
1618                                                 (const unsigned char *) sep->endpoint.addr,
1619                                                  sizeof(sep->endpoint.addr));
1620             ret = mbedtls_ssl_handshake_step(&peer->ssl);
1621         }
1622         uint32_t flags = mbedtls_ssl_get_verify_result(&peer->ssl);
1623         if (0 != flags)
1624         {
1625             OIC_LOG_BUFFER(ERROR, NET_SSL_TAG, (const uint8_t *) &flags, sizeof(flags));
1626             SSL_CHECK_FAIL(peer, flags, "Cert verification failed", 1,
1627                                                      CA_STATUS_FAILED, GetAlertCode(flags));
1628         }
1629         SSL_CHECK_FAIL(peer, ret, "Handshake error", 1, CA_STATUS_FAILED, MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE);
1630         if (MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC == peer->ssl.state)
1631         {
1632             memcpy(peer->master, peer->ssl.session_negotiate->master, sizeof(peer->master));
1633             g_caSslContext->selectedCipher = peer->ssl.session_negotiate->ciphersuite;
1634         }
1635         if (MBEDTLS_SSL_CLIENT_KEY_EXCHANGE == peer->ssl.state)
1636         {
1637             memcpy(peer->random, peer->ssl.handshake->randbytes, sizeof(peer->random));
1638         }
1639
1640         if (MBEDTLS_SSL_HANDSHAKE_OVER == peer->ssl.state)
1641         {
1642             SSL_RES(peer, CA_STATUS_OK);
1643             if (MBEDTLS_SSL_IS_CLIENT == peer->ssl.conf->endpoint)
1644             {
1645                 SendCacheMessages(peer);
1646             }
1647
1648             if (MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8 == g_caSslContext->selectedCipher ||
1649                 MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA == g_caSslContext->selectedCipher)
1650             {
1651                 char uuid[UUID_LENGTH * 2 + 5] = {0};
1652                 void * uuidPos = NULL;
1653                 void * userIdPos = NULL;
1654                 const mbedtls_x509_crt * peerCert = mbedtls_ssl_get_peer_cert(&peer->ssl);
1655                 ret = (NULL == peerCert ? -1 : 0);
1656                 SSL_CHECK_FAIL(peer, ret, "Failed to retrieve cert", 1,
1657                                             CA_STATUS_FAILED, MBEDTLS_SSL_ALERT_MSG_NO_CERT);
1658                 uuidPos = memmem(peerCert->subject_raw.p, peerCert->subject_raw.len,
1659                                                  UUID_PREFIX, sizeof(UUID_PREFIX) - 1);
1660
1661                 if (NULL != uuidPos)
1662                 {
1663                     memcpy(uuid, (char*) uuidPos + sizeof(UUID_PREFIX) - 1, UUID_LENGTH * 2 + 4);
1664                     ret = ConvertStrToUuid(uuid, &peer->sep.identity);
1665                     SSL_CHECK_FAIL(peer, ret, "Failed to convert subject", 1,
1666                                           CA_STATUS_FAILED, MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT);
1667                 }
1668                 else
1669                 {
1670                     OIC_LOG(WARNING, NET_SSL_TAG, "uuid not found");
1671                 }
1672
1673                 userIdPos = memmem(peerCert->subject_raw.p, peerCert->subject_raw.len,
1674                                              USERID_PREFIX, sizeof(USERID_PREFIX) - 1);
1675                 if (NULL != userIdPos)
1676                 {
1677                     memcpy(uuid, (char*) userIdPos + sizeof(USERID_PREFIX) - 1, UUID_LENGTH * 2 + 4);
1678                     ret = ConvertStrToUuid(uuid, &peer->sep.userId);
1679                     SSL_CHECK_FAIL(peer, ret, "Failed to convert subject alt name", 1,
1680                                       CA_STATUS_FAILED, MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT);
1681                 }
1682                 else
1683                 {
1684                     OIC_LOG(WARNING, NET_SSL_TAG, "Subject alternative name not found");
1685                 }
1686             }
1687
1688             ca_mutex_unlock(g_sslContextMutex);
1689             OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1690             return CA_STATUS_OK;
1691         }
1692     }
1693
1694     if (MBEDTLS_SSL_HANDSHAKE_OVER == peer->ssl.state)
1695     {
1696         uint8_t decryptBuffer[TLS_MSG_BUF_LEN] = {0};
1697         do
1698         {
1699             ret = mbedtls_ssl_read(&peer->ssl, decryptBuffer, TLS_MSG_BUF_LEN);
1700         } while (MBEDTLS_ERR_SSL_WANT_READ == ret);
1701
1702         if (MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY == ret)
1703         {
1704             OIC_LOG(INFO, NET_SSL_TAG, "Connection was closed gracefully");
1705             SSL_CLOSE_NOTIFY(peer, ret);
1706             RemovePeerFromList(&peer->sep.endpoint);
1707             ca_mutex_unlock(g_sslContextMutex);
1708             return CA_STATUS_OK;
1709         }
1710
1711         if (0 > ret)
1712         {
1713             OIC_LOG_V(ERROR, NET_SSL_TAG, "mbedtls_ssl_read returned -0x%x", -ret);
1714             //SSL_RES(peer, CA_STATUS_FAILED);
1715             RemovePeerFromList(&peer->sep.endpoint);
1716             ca_mutex_unlock(g_sslContextMutex);
1717             return CA_STATUS_FAILED;
1718         }
1719         int adapterIndex = GetAdapterIndex(peer->sep.endpoint.adapter);
1720         if (0 == adapterIndex || adapterIndex == 1)
1721         {
1722             g_caSslContext->adapterCallbacks[adapterIndex].recvCallback(&peer->sep, decryptBuffer, ret);
1723         }
1724         else
1725         {
1726             OIC_LOG(ERROR, NET_SSL_TAG, "Unsuported adapter");
1727             RemovePeerFromList(&peer->sep.endpoint);
1728             ca_mutex_unlock(g_sslContextMutex);
1729             return CA_STATUS_FAILED;
1730         }
1731     }
1732
1733     ca_mutex_unlock(g_sslContextMutex);
1734     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1735     return CA_STATUS_OK;
1736 }
1737
1738 void CAsetSslAdapterCallbacks(CAPacketReceivedCallback recvCallback,
1739                               CAPacketSendCallback sendCallback,
1740                               CATransportAdapter_t type)
1741 {
1742     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1743     VERIFY_NON_NULL_VOID(sendCallback, NET_SSL_TAG, "sendCallback is NULL");
1744     VERIFY_NON_NULL_VOID(recvCallback, NET_SSL_TAG, "recvCallback is NULL");
1745     ca_mutex_lock(g_sslContextMutex);
1746     if (NULL == g_caSslContext)
1747     {
1748         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
1749         ca_mutex_unlock(g_sslContextMutex);
1750         return;
1751     }
1752
1753 //    if (MAX_SUPPORTED_ADAPTERS > type)
1754     {
1755         switch (type)
1756         {
1757             case CA_ADAPTER_IP:
1758                 g_caSslContext->adapterCallbacks[0].recvCallback = recvCallback;
1759                 g_caSslContext->adapterCallbacks[0].sendCallback = sendCallback;
1760                 break;
1761             case CA_ADAPTER_TCP:
1762                 g_caSslContext->adapterCallbacks[1].recvCallback = recvCallback;
1763                 g_caSslContext->adapterCallbacks[1].sendCallback = sendCallback;
1764                 break;
1765             default:
1766                 OIC_LOG_V(ERROR, NET_SSL_TAG, "Unsupported adapter: %d", type);
1767         }
1768     }
1769
1770     ca_mutex_unlock(g_sslContextMutex);
1771     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1772 }
1773
1774 CAResult_t CAsetTlsCipherSuite(const uint32_t cipher)
1775 {
1776     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1777     VERIFY_NON_NULL_RET(g_getCredentialTypesCallback, NET_SSL_TAG, "Param callback is null", CA_STATUS_FAILED);
1778     g_getCredentialTypesCallback(g_caSslContext->cipherFlag);
1779     switch(cipher)
1780     {
1781         case MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA:
1782         {
1783 #ifdef __WITH_TLS__
1784             //todo check that Cred with RSA cert exists
1785             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->clientTlsConf,
1786                                          tlsCipher[ADAPTER_TLS_RSA_WITH_AES_256_CBC_SHA]);
1787             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->serverTlsConf,
1788                                          tlsCipher[ADAPTER_TLS_RSA_WITH_AES_256_CBC_SHA]);
1789 #endif
1790 #ifdef __WITH_DTLS__
1791             //todo check that Cred with RSA cert exists
1792             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->clientDtlsConf,
1793                                          tlsCipher[ADAPTER_TLS_RSA_WITH_AES_256_CBC_SHA]);
1794             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->serverDtlsConf,
1795                                          tlsCipher[ADAPTER_TLS_RSA_WITH_AES_256_CBC_SHA]);
1796 #endif
1797             g_caSslContext->cipher = ADAPTER_TLS_RSA_WITH_AES_256_CBC_SHA;
1798             break;
1799         }
1800         case MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8:
1801         {
1802             if (false == g_caSslContext->cipherFlag[1])
1803             {
1804                 OIC_LOG(ERROR, NET_SSL_TAG, "No Credential for ECC");
1805                 return CA_STATUS_FAILED;
1806             }
1807 #ifdef __WITH_TLS__
1808             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->clientTlsConf,
1809                                          tlsCipher[ADAPTER_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8]);
1810             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->serverTlsConf,
1811                                          tlsCipher[ADAPTER_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8]);
1812 #endif
1813 #ifdef __WITH_DTLS__
1814             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->clientDtlsConf,
1815                                          tlsCipher[ADAPTER_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8]);
1816             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->serverDtlsConf,
1817                                          tlsCipher[ADAPTER_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8]);
1818 #endif
1819             g_caSslContext->cipher = ADAPTER_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8;
1820             break;
1821         }
1822         case MBEDTLS_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA256:
1823         {
1824 #ifdef __WITH_TLS__
1825             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->clientTlsConf,
1826                                          tlsCipher[ADAPTER_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA_256]);
1827             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->serverTlsConf,
1828                                          tlsCipher[ADAPTER_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA_256]);
1829 #endif
1830 #ifdef __WITH_DTLS__
1831             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->clientDtlsConf,
1832                                          tlsCipher[ADAPTER_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA_256]);
1833             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->serverDtlsConf,
1834                                          tlsCipher[ADAPTER_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA_256]);
1835 #endif
1836             g_caSslContext->cipher = ADAPTER_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA_256;
1837             break;
1838         }
1839         case MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256:
1840         {
1841 #if 0 // PIN OTM
1842             if (false == g_caSslContext->cipherFlag[0])
1843             {
1844                 OIC_LOG(ERROR, NET_SSL_TAG, "No Credential for PSK");
1845                 return CA_STATUS_FAILED;
1846             }
1847 #endif
1848 #ifdef __WITH_TLS__
1849             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->clientTlsConf,
1850                                           tlsCipher[ADAPTER_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256]);
1851             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->serverTlsConf,
1852                                           tlsCipher[ADAPTER_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256]);
1853 #endif
1854 #ifdef __WITH_DTLS__
1855             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->clientDtlsConf,
1856                                           tlsCipher[ADAPTER_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256]);
1857             mbedtls_ssl_conf_ciphersuites(&g_caSslContext->serverDtlsConf,
1858                                           tlsCipher[ADAPTER_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256]);
1859 #endif
1860             g_caSslContext->cipher = ADAPTER_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256;
1861             break;
1862         }
1863         default:
1864         {
1865             OIC_LOG(ERROR, NET_SSL_TAG, "Unknown cipher");
1866             return CA_STATUS_FAILED;
1867         }
1868     }
1869     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Selected cipher: 0x%x", cipher);
1870     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1871     return CA_STATUS_OK;
1872 }
1873
1874 CAResult_t CAinitiateSslHandshake(const CAEndpoint_t *endpoint)
1875 {
1876     CAResult_t res = CA_STATUS_OK;
1877     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1878     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG, "Param endpoint is NULL" , CA_STATUS_INVALID_PARAM);
1879     ca_mutex_lock(g_sslContextMutex);
1880     if (NULL == InitiateTlsHandshake(endpoint))
1881     {
1882         OIC_LOG(ERROR, NET_SSL_TAG, "TLS handshake failed");
1883         res = CA_STATUS_FAILED;
1884     }
1885     ca_mutex_unlock(g_sslContextMutex);
1886     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1887     return res;
1888 }
1889 /**
1890  * Expands the secret into blocks of data according
1891  * to the algorithm specified in section 5 of RFC 4346
1892  *
1893  * This function writes upto @p bufLen bytes into the given output buffer @p buf
1894  *
1895  * @param  key    secret key.
1896  * @param  keyLen    secret key length.
1897  * @param  label    A PRF label.
1898  * @param  labelLen     Actual length of @p label.
1899  * @param  random1    Random seed.
1900  * @param  random1Len     Actual length of @p random1 (may be zero).
1901  * @param  random2     Random seed.
1902  * @param  random2Len    Actual length of @p random2 (may be zero).
1903  * @param  buf    Output buffer for generated random data.
1904  * @param  bufLen    Maximum size of @p buf.
1905  *
1906  * @return The actual number of bytes written to @p buf or @c -1 on error.
1907  */
1908
1909 static int pHash (const unsigned char *key, size_t keyLen,
1910      const unsigned char *label, size_t labelLen,
1911      const unsigned char *random1, size_t random1Len,
1912      const unsigned char *random2, size_t random2Len,
1913      unsigned char *buf, size_t bufLen)
1914 {
1915     unsigned char A[RANDOM_LEN] = {0};
1916     unsigned char tmp[RANDOM_LEN] = {0};
1917     size_t dLen;   /* digest length */
1918     size_t len = 0;   /* result length */
1919
1920     VERIFY_NON_NULL_RET(key, NET_SSL_TAG, "key is NULL", -1);
1921     VERIFY_NON_NULL_RET(label, NET_SSL_TAG, "label is NULL", -1);
1922     VERIFY_NON_NULL_RET(random1, NET_SSL_TAG, "random1 is NULL", -1);
1923     VERIFY_NON_NULL_RET(random2, NET_SSL_TAG, "random2 is NULL", -1);
1924     VERIFY_NON_NULL_RET(buf, NET_SSL_TAG, "buf is NULL", -1);
1925
1926     mbedtls_md_context_t hmacA;
1927     mbedtls_md_context_t hmacP;
1928
1929     mbedtls_md_init(&hmacA);
1930     mbedtls_md_init(&hmacP);
1931
1932     CHECK_MBEDTLS_RET(mbedtls_md_setup, &hmacA, mbedtls_md_info_from_type(MBEDTLS_MD_SHA256), 1);
1933     CHECK_MBEDTLS_RET(mbedtls_md_setup, &hmacP, mbedtls_md_info_from_type(MBEDTLS_MD_SHA256), 1);
1934
1935     CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacA, key, keyLen );
1936     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacA, label, labelLen);
1937     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacA, random1, random1Len);
1938     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacA, random2, random2Len);
1939     CHECK_MBEDTLS_RET(mbedtls_md_hmac_finish, &hmacA, A);
1940
1941     dLen = RANDOM_LEN;
1942
1943     CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacP, key, keyLen);
1944
1945     while (len + dLen < bufLen)
1946     {
1947         CHECK_MBEDTLS_RET(mbedtls_md_hmac_reset, &hmacP);
1948         CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacP, key, keyLen);
1949         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, A, dLen);
1950         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, label, labelLen);
1951         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, random1, random1Len);
1952         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, random2, random2Len);
1953
1954         CHECK_MBEDTLS_RET(mbedtls_md_hmac_finish, &hmacP, tmp);
1955
1956         len += RANDOM_LEN;
1957
1958         memcpy(buf, tmp, dLen);
1959         buf += dLen;
1960
1961         CHECK_MBEDTLS_RET(mbedtls_md_hmac_reset, &hmacA);
1962         CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacA, key, keyLen);
1963         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacA, A, dLen);
1964         CHECK_MBEDTLS_RET(mbedtls_md_hmac_finish, &hmacA, A);
1965     }
1966
1967     CHECK_MBEDTLS_RET(mbedtls_md_hmac_reset, &hmacP);
1968     CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacP, key, keyLen);
1969     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, A, dLen);
1970
1971     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, label, labelLen);
1972     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, random1, random1Len);
1973     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, random2, random2Len);
1974     CHECK_MBEDTLS_RET(mbedtls_md_hmac_finish, &hmacP, tmp);
1975
1976     memcpy(buf, tmp, bufLen - len);
1977
1978     mbedtls_md_free(&hmacA);
1979     mbedtls_md_free(&hmacP);
1980     return bufLen;
1981
1982 exit:
1983     mbedtls_md_free(&hmacA);
1984     mbedtls_md_free(&hmacP);
1985     return -1;
1986 }
1987
1988 CAResult_t CAsslGenerateOwnerPsk(const CAEndpoint_t *endpoint,
1989                             const uint8_t* label, const size_t labelLen,
1990                             const uint8_t* rsrcServerDeviceId, const size_t rsrcServerDeviceIdLen,
1991                             const uint8_t* provServerDeviceId, const size_t provServerDeviceIdLen,
1992                             uint8_t* ownerPsk, const size_t ownerPskSize)
1993 {
1994     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1995     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG, "endpoint is NULL", CA_STATUS_INVALID_PARAM);
1996     VERIFY_NON_NULL_RET(label, NET_SSL_TAG, "label is NULL", CA_STATUS_INVALID_PARAM);
1997     VERIFY_NON_NULL_RET(rsrcServerDeviceId, NET_SSL_TAG, "rsrcId is NULL", CA_STATUS_INVALID_PARAM);
1998     VERIFY_NON_NULL_RET(provServerDeviceId, NET_SSL_TAG, "provId is NULL", CA_STATUS_INVALID_PARAM);
1999     VERIFY_NON_NULL_RET(ownerPsk, NET_SSL_TAG, "ownerPSK is NULL", CA_STATUS_INVALID_PARAM);
2000
2001     // TODO: Added as workaround, need to debug
2002     ca_mutex_unlock(g_sslContextMutex);
2003
2004     ca_mutex_lock(g_sslContextMutex);
2005     if (NULL == g_caSslContext)
2006     {
2007         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
2008         ca_mutex_unlock(g_sslContextMutex);
2009         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2010         return CA_STATUS_FAILED;
2011     }
2012     SslEndPoint_t * tep = GetSslPeer(endpoint);
2013     if (NULL == tep)
2014     {
2015         OIC_LOG(ERROR, NET_SSL_TAG, "Session does not exist");
2016         ca_mutex_unlock(g_sslContextMutex);
2017         return CA_STATUS_FAILED;
2018     }
2019
2020     uint8_t keyblock[KEY_BLOCK_LEN] = {0};
2021     // "key expansion"
2022     uint8_t lab[] = {0x6b, 0x65, 0x79, 0x20, 0x65, 0x78, 0x70, 0x61, 0x6e, 0x73, 0x69, 0x6f, 0x6e};
2023     int ret = pHash(tep->master, sizeof(tep->master), lab, sizeof(lab),
2024                     (tep->random) + RANDOM_LEN, RANDOM_LEN, tep->random, RANDOM_LEN,
2025                     keyblock, KEY_BLOCK_LEN);
2026     if (-1 == ret)
2027     {
2028         OIC_LOG(ERROR, NET_SSL_TAG, "PSK not generated");
2029         ca_mutex_unlock(g_sslContextMutex);
2030         return CA_STATUS_FAILED;
2031     }
2032     ret = pHash(keyblock, sizeof(keyblock), label, labelLen,
2033                 rsrcServerDeviceId, rsrcServerDeviceIdLen,
2034                 provServerDeviceId, provServerDeviceIdLen,
2035                 ownerPsk, ownerPskSize);
2036     if (-1 == ret)
2037     {
2038         OIC_LOG(ERROR, NET_SSL_TAG, "PSK not generated");
2039         ca_mutex_unlock(g_sslContextMutex);
2040         return CA_STATUS_FAILED;
2041     }
2042
2043     ca_mutex_unlock(g_sslContextMutex);
2044
2045     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2046     return CA_STATUS_OK;
2047 }