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 MBEDTLS_SSL_SRV_RESPECT_CLIENT_PREFERENCE
  22
  23 #ifndef _GNU_SOURCE
  24 #define _GNU_SOURCE
  25 #endif // _GNU_SOURCE
  26
  27 #include <stddef.h>
  28 #include <stdint.h>
  29 #include <stdbool.h>
  30 #include "ca_adapter_net_ssl.h"
  31 #include "cacommon.h"
  32 #include "caadapterutils.h"
  33 #include "cainterface.h"
  34 #include "caipinterface.h"
  35 #include "oic_malloc.h"
  36 #include "ocrandom.h"
  37 #include "byte_array.h"
  38 #include "octhread.h"
  39 #include "timer.h"
  40
  41
  42 // headers required for mbed TLS
  43 #include "mbedtls/platform.h"
  44 #include "mbedtls/ssl.h"
  45 #include "mbedtls/entropy.h"
  46 #include "mbedtls/ctr_drbg.h"
  47 #include "mbedtls/pkcs12.h"
  48 #include "mbedtls/ssl_internal.h"
  49 #include "mbedtls/net.h"
  50 #ifdef __WITH_DTLS__
  51 #include "mbedtls/timing.h"
  52 #include "mbedtls/ssl_cookie.h"
  53 #endif
  54 #include "pkix_interface.h"
  55
  56 #if !defined(NDEBUG) || defined(TB_LOG)
  57 #include "mbedtls/debug.h"
  58 #include "mbedtls/version.h"
  59 #endif
  60
  61 #ifdef __unix__
  62 #include <sys/types.h>
  63 #include <sys/stat.h>
  64 #include <fcntl.h>
  65 #include <unistd.h>
  66 #endif
  67
  68
  69 /**
  70  * @def MBED_TLS_VERSION_LEN
  71  * @brief mbedTLS version string length
  72  */
  73 #define MBED_TLS_VERSION_LEN (16)
  74 /**
  75  * @def SEED
  76  * @brief Seed for initialization RNG
  77  */
  78 #define SEED "IOTIVITY_RND"
  79 /**
  80  * @def UUID_PREFIX
  81  * @brief uuid prefix in certificate subject field
  82  */
  83 #define UUID_PREFIX "uuid:"
  84 /**
  85  * @def USERID_PREFIX
  86  * @brief userid prefix in certificate alternative subject name field
  87  */
  88 #define USERID_PREFIX "userid:"
  89
  90 /**
  91  * @def NET_SSL_TAG
  92  * @brief Logging tag for module name
  93  */
  94 #define NET_SSL_TAG "OIC_CA_NET_SSL"
  95 /**
  96  * @def MBED_TLS_TAG
  97  * @brief Logging tag for mbedTLS library
  98  */
  99 #define MBED_TLS_TAG "MBED_TLS"
 100 /**
 101  * @def MMBED_TLS_DEBUG_LEVEL
 102  * @brief Logging level for mbedTLS library
 103  */
 104 #define MBED_TLS_DEBUG_LEVEL (4)
 105
 106 /**
 107  * @def TLS_MSG_BUF_LEN
 108  * @brief Buffer size for TLS record. A single TLS record may be up to 16384 octets in length
 109  */
 110 #if defined (__TIZENRT__)
 111 #define TLS_MSG_BUF_LEN (2048)
 112 #else
 113 #define TLS_MSG_BUF_LEN (16384)
 114 #endif
 115
 116 /**
 117  * @def PSK_LENGTH
 118  * @brief PSK keys max length
 119  */
 120 #define PSK_LENGTH (256/8)
 121 /**
 122  * @def UUID_LENGTHPSK_LENGTH
 123  * @brief Identity max length
 124  */
 125 #define UUID_LENGTH (128/8)
 126 /**
 127  * @def MASTER_SECRET_LEN
 128  * @brief TLS master secret length
 129  */
 130 #define MASTER_SECRET_LEN (48)
 131 /**
 132  * @def RANDOM_LEN
 133  * @brief TLS client and server random bytes length
 134  */
 135 #define RANDOM_LEN (32)
 136 /**
 137  * @def SHA384_MAC_KEY_LENGTH
 138  * @brief MAC key length for SHA384 cipher suites
 139  */
 140 #define SHA384_MAC_KEY_LENGTH (48)
 141 /**
 142  * @def SHA256_MAC_KEY_LENGTH
 143  * @brief MAC key length for SHA256 cipher suites
 144  */
 145 #define SHA256_MAC_KEY_LENGTH (32)
 146 /**
 147  * @def CCM_MAC_KEY_LENGTH
 148  * @brief MAC key length for CCM cipher suites
 149  */
 150 #define CCM_MAC_KEY_LENGTH (0)
 151 /**
 152  * @def AES256_KEY_LENGTH
 153  * @brief key material length for AES256 cipher suites
 154  */
 155 #define AES256_KEY_LENGTH (32)
 156 /**
 157  * @def AES128_KEY_LENGTH
 158  * @brief key material length for AES128 cipher suites
 159  */
 160 #define AES128_KEY_LENGTH (16)
 161 /**
 162  * @def GCM_IV_LENGTH
 163  * @brief length of nonce for GCM cipher suites
 164  */
 165 #define GCM_IV_LENGTH (12)
 166 /**
 167  * @def CCM_IV_LENGTH
 168  * @brief length of nonce for CCM cipher suites
 169  */
 170 #define CCM_IV_LENGTH (4)
 171 /**
 172  * @def CBC_IV_LENGTH
 173  * @brief length of nonce for CBC cipher suites
 174  */
 175 #define CBC_IV_LENGTH (0)
 176
 177 /**
 178  * @var RETRANSMISSION_TIME
 179  * @brief Maximum timeout value (in seconds) to start DTLS retransmission.
 180  */
 181 #define RETRANSMISSION_TIME 1
 182
 183 /**@def SSL_CLOSE_NOTIFY(peer, ret)
 184  *
 185  * Notifies of existing \a peer about closing TLS connection.
 186  *
 187  * @param[in] peer remote peer
 188  * @param[in] ret used internaly
 189  */
 190 #define SSL_CLOSE_NOTIFY(peer, ret)                                                                \
 191 do                                                                                                 \
 192 {                                                                                                  \
 193     (ret) = mbedtls_ssl_close_notify(&(peer)->ssl);                                                \
 194 } while (MBEDTLS_ERR_SSL_WANT_WRITE == (ret))
 195
 196 /**@def SSL_RES(peer, status)
 197  *
 198  * Sets SSL result for callback.
 199  *
 200  * @param[in] peer remote peer
 201  */
 202 #define SSL_RES(peer, status)                                                                      \
 203 if (g_sslCallback)                                                                                 \
 204 {                                                                                                  \
 205     CAErrorInfo_t errorInfo;                                                                       \
 206     errorInfo.result = (status);                                                                   \
 207     g_sslCallback(&(peer)->sep.endpoint, &errorInfo);                                              \
 208 }
 209 /**@def SSL_CHECK_FAIL(peer, ret, str, mutex, error, msg)
 210  *
 211  * Checks handshake result and send alert if needed.
 212  *
 213  * @param[in] peer remote peer
 214  * @param[in] ret error code
 215  * @param[in] str debug string
 216  * @param[in] mutex ca mutex
 217  * @param[in] error if code does not equal to -1 returns error code
 218  * @param[in] msg allert message
 219  */
 220 #define SSL_CHECK_FAIL(peer, ret, str, mutex, error, msg)                                          \
 221 if (0 != (ret) && MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY != (int) (ret) &&                              \
 222     MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED != (int) (ret) &&                                        \
 223     MBEDTLS_ERR_SSL_WANT_READ != (int) (ret) &&                                                    \
 224     MBEDTLS_ERR_SSL_WANT_WRITE != (int) (ret) &&                                                   \
 225     MBEDTLS_ERR_SSL_NON_FATAL != (int) (ret) &&                                                    \
 226     MBEDTLS_SSL_ALERT_MSG_USER_CANCELED != (int) (ret) &&                                          \
 227     MBEDTLS_SSL_ALERT_MSG_NO_RENEGOTIATION != (int) (ret) &&                                       \
 228     MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_EXT != (int) (ret) &&                                        \
 229     MBEDTLS_SSL_ALERT_MSG_CLOSE_NOTIFY != (int) (ret) &&                                           \
 230     MBEDTLS_SSL_ALERT_MSG_NO_CERT != (int) (ret) &&                                                \
 231     MBEDTLS_SSL_ALERT_MSG_BAD_CERT != (int) (ret) &&                                               \
 232     MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT != (int) (ret) &&                                       \
 233     MBEDTLS_SSL_ALERT_MSG_CERT_REVOKED != (int) (ret) &&                                           \
 234     MBEDTLS_SSL_ALERT_MSG_CERT_EXPIRED != (int) (ret) &&                                           \
 235     MBEDTLS_SSL_ALERT_MSG_CERT_UNKNOWN != (int) (ret) &&                                           \
 236     MBEDTLS_SSL_ALERT_MSG_INAPROPRIATE_FALLBACK != (int) (ret) &&                                  \
 237     MBEDTLS_SSL_ALERT_MSG_UNRECOGNIZED_NAME != (int) (ret) &&                                      \
 238     MBEDTLS_SSL_ALERT_MSG_UNKNOWN_PSK_IDENTITY != (int) (ret) &&                                   \
 239     MBEDTLS_SSL_ALERT_MSG_NO_APPLICATION_PROTOCOL != (int) (ret))                                  \
 240 {                                                                                                  \
 241     OIC_LOG_V(ERROR, NET_SSL_TAG, "%s: -0x%x", (str), -(ret));                                     \
 242     if ((int) MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE != (int) (ret) &&                                \
 243         (int) MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO != (int) (ret))                                  \
 244     {                                                                                              \
 245         mbedtls_ssl_send_alert_message(&(peer)->ssl, MBEDTLS_SSL_ALERT_LEVEL_FATAL, (msg));        \
 246     }                                                                                              \
 247     RemovePeerFromList(&(peer)->sep.endpoint);                                                     \
 248     if (mutex)                                                                                     \
 249     {                                                                                              \
 250         oc_mutex_unlock(g_sslContextMutex);                                                        \
 251     }                                                                                              \
 252     if ((int) MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO != (int)(ret))                                   \
 253     {                                                                                              \
 254         SSL_RES((peer), CA_DTLS_AUTHENTICATION_FAILURE);                                           \
 255     }                                                                                              \
 256     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);                                             \
 257     if (-1 != (intptr_t)error)                                                                               \
 258     {                                                                                              \
 259         return (error);                                                                            \
 260     }                                                                                              \
 261 }
 262
 263 /**@def CONF_SSL(clientConf, serverConf, fn, ...)
 264  *
 265  * Calls \a fn for \a clientConf and \a serverConf.
 266  *
 267  */
 268 #define CONF_SSL(clientConf, serverConf, fn, ...) do {                                             \
 269 fn((clientConf), __VA_ARGS__);                                                                     \
 270 fn((serverConf), __VA_ARGS__);                                                                     \
 271 } while (0)
 272
 273 /** @def CHECK_MBEDTLS_RET(f, ...)
 274  * A macro that checks \a f function return code
 275  *
 276  * If function returns error code it goes to error processing.
 277  *
 278  * @param[in] f  Function to call
 279  */
 280 #define CHECK_MBEDTLS_RET(f, ...) do {                                                             \
 281 int ret = (f)(__VA_ARGS__);                                                                        \
 282 if (0 != ret) {                                                                                    \
 283     OIC_LOG_V(ERROR, NET_SSL_TAG, "%s returned -0x%04x\n", __func__, -(ret));                      \
 284     goto exit;                                                                                     \
 285 } } while (0)
 286
 287 typedef enum
 288 {
 289     SSL_RSA_WITH_AES_256_CBC_SHA256,
 290     SSL_RSA_WITH_AES_128_GCM_SHA256,
 291     SSL_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
 292     SSL_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
 293     SSL_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
 294     SSL_ECDHE_ECDSA_WITH_AES_128_CCM_8,
 295     SSL_ECDHE_ECDSA_WITH_AES_128_CCM,
 296     SSL_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
 297     SSL_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,
 298     SSL_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
 299     SSL_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
 300     SSL_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
 301     SSL_ECDH_ANON_WITH_AES_128_CBC_SHA256,
 302     SSL_CIPHER_MAX
 303 } SslCipher_t;
 304
 305 typedef enum
 306 {
 307     ADAPTER_CURVE_SECP256R1,
 308     ADAPTER_CURVE_MAX
 309 } AdapterCurve_t;
 310
 311 static const int tlsCipher[SSL_CIPHER_MAX][2] =
 312 {
 313     {MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA256, 0},
 314     {MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256, 0},
 315     {MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, 0},
 316     {MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, 0},
 317     {MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, 0},
 318     {MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8, 0},
 319     {MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM, 0},
 320     {MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, 0},
 321     {MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384, 0},
 322     {MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, 0},
 323     {MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256, 0},
 324     {MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, 0},
 325     {MBEDTLS_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA256, 0}
 326 };
 327
 328 static int g_cipherSuitesList[SSL_CIPHER_MAX];
 329
 330 static int g_ssl_ordered_default_hashes[] = {
 331 #if defined(MBEDTLS_SHA256_C)
 332     MBEDTLS_MD_SHA256,
 333     MBEDTLS_MD_SHA224,
 334 #endif
 335 #if defined(MBEDTLS_SHA1_C)
 336     MBEDTLS_MD_SHA1,
 337 #endif
 338     MBEDTLS_MD_NONE
 339 };
 340
 341 mbedtls_ecp_group_id curve[ADAPTER_CURVE_MAX][2] =
 342 {
 343     {MBEDTLS_ECP_DP_SECP256R1, MBEDTLS_ECP_DP_NONE}
 344 };
 345
 346 static PkiInfo_t g_pkiInfo = {{NULL, 0}, {NULL, 0}, {NULL, 0}, {NULL, 0}};
 347
 348 typedef struct  {
 349     int code;
 350     int alert;
 351 } CrtVerifyAlert_t;
 352
 353 static const CrtVerifyAlert_t crtVerifyAlerts[] = {
 354     {MBEDTLS_X509_BADCERT_EXPIRED,       MBEDTLS_SSL_ALERT_MSG_CERT_EXPIRED},
 355     {MBEDTLS_X509_BADCERT_REVOKED,       MBEDTLS_SSL_ALERT_MSG_CERT_REVOKED},
 356     {MBEDTLS_X509_BADCERT_CN_MISMATCH,   MBEDTLS_SSL_ALERT_MSG_CERT_UNKNOWN},
 357     {MBEDTLS_X509_BADCERT_NOT_TRUSTED,   MBEDTLS_SSL_ALERT_MSG_UNKNOWN_CA},
 358     {MBEDTLS_X509_BADCRL_NOT_TRUSTED,    MBEDTLS_SSL_ALERT_MSG_UNKNOWN_CA},
 359     {MBEDTLS_X509_BADCRL_EXPIRED,        MBEDTLS_SSL_ALERT_MSG_INSUFFICIENT_SECURITY},
 360     {MBEDTLS_X509_BADCERT_MISSING,       MBEDTLS_SSL_ALERT_MSG_NO_CERT},
 361     {MBEDTLS_X509_BADCERT_SKIP_VERIFY,   MBEDTLS_SSL_ALERT_MSG_INSUFFICIENT_SECURITY},
 362     {MBEDTLS_X509_BADCERT_OTHER,         MBEDTLS_SSL_ALERT_MSG_INTERNAL_ERROR},
 363     {MBEDTLS_X509_BADCERT_FUTURE,        MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 364     {MBEDTLS_X509_BADCRL_FUTURE,         MBEDTLS_SSL_ALERT_MSG_INSUFFICIENT_SECURITY},
 365     {MBEDTLS_X509_BADCERT_KEY_USAGE,     MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 366     {MBEDTLS_X509_BADCERT_EXT_KEY_USAGE, MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 367     {MBEDTLS_X509_BADCERT_NS_CERT_TYPE,  MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 368     {MBEDTLS_X509_BADCERT_BAD_MD,        MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 369     {MBEDTLS_X509_BADCERT_BAD_PK,        MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 370     {MBEDTLS_X509_BADCERT_BAD_KEY,       MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 371     {MBEDTLS_X509_BADCRL_BAD_MD,         MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 372     {MBEDTLS_X509_BADCRL_BAD_PK,         MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 373     {MBEDTLS_X509_BADCRL_BAD_KEY,        MBEDTLS_SSL_ALERT_MSG_BAD_CERT},
 374     {0, 0}
 375 };
 376
 377 static int GetAlertCode(uint32_t flags)
 378 {
 379     const CrtVerifyAlert_t *cur;
 380
 381     for (cur = crtVerifyAlerts; cur->alert != 0 ; cur++)
 382     {
 383         if (flags & cur->code)
 384         {
 385             return cur->alert;
 386         }
 387     }
 388     return 0;
 389 }
 390
 391 #if !defined(NDEBUG) || defined(TB_LOG)
 392 /**
 393  * Pass a message to the OIC logger.
 394  *
 395  * @param[in] ctx  opaque context for the callback
 396  * @param[in] level  debug level
 397  * @param[in] file  file name
 398  * @param[in] line  line number
 399  * @param[in] str  message
 400  */
 401 static void DebugSsl(void *ctx, int level, const char *file, int line, const char *str)
 402 {
 403     ((void) level);
 404     ((void) file);
 405     ((void) line);
 406     ((void) ctx);
 407
 408     OIC_LOG_V(DEBUG, MBED_TLS_TAG, "%s", str);
 409 }
 410 #endif
 411
 412 #if defined(_WIN32) || defined (__TIZENRT__)
 413 /*
 414  * Finds the first occurrence of the byte string s in byte string l.
 415  */
 416
 417 static void * memmem(const void *l, size_t lLen, const void *s, size_t sLen)
 418 {
 419     char *cur;
 420     char *last;
 421     const char *cl = (const char *)l;
 422     const char *cs = (const char *)s;
 423
 424     if (lLen == 0 || sLen == 0)
 425     {
 426         return NULL;
 427     }
 428     if (lLen < sLen)
 429     {
 430         return NULL;
 431     }
 432     if (sLen == 1)
 433     {
 434         return (void *)memchr(l, (int)*cs, lLen);
 435     }
 436
 437     last = (char *)cl + lLen - sLen;
 438
 439     for (cur = (char *)cl; cur <= last; cur++)
 440     {
 441         if (cur[0] == cs[0] && memcmp(cur, cs, sLen) == 0)
 442         {
 443             return cur;
 444         }
 445     }
 446     return NULL;
 447 }
 448 #endif
 449 /**
 450  * structure to holds the information of cache message and address info.
 451  */
 452 typedef ByteArray_t SslCacheMessage_t;
 453
 454
 455 /**
 456  * Data structure for holding the send and recv callbacks.
 457  */
 458 typedef struct TlsCallBacks
 459 {
 460     CAPacketReceivedCallback recvCallback;  /**< Callback used to send data to upper layer. */
 461     CAPacketSendCallback sendCallback;      /**< Callback used to send data to socket layer. */
 462 } SslCallbacks_t;
 463
 464 /**
 465  * Data structure for holding the mbedTLS interface related info.
 466  */
 467 typedef struct SslContext
 468 {
 469     u_arraylist_t *peerList;         /**< peer list which holds the mapping between
 470                                               peer id, it's n/w address and mbedTLS context. */
 471     mbedtls_entropy_context entropy;
 472     mbedtls_ctr_drbg_context rnd;
 473     mbedtls_x509_crt ca;
 474     mbedtls_x509_crt crt;
 475     mbedtls_pk_context pkey;
 476
 477     mbedtls_ssl_config clientTlsConf;
 478     mbedtls_ssl_config serverTlsConf;
 479     mbedtls_ssl_config clientDtlsConf;
 480     mbedtls_ssl_config serverDtlsConf;
 481
 482     SslCipher_t cipher;
 483     SslCallbacks_t adapterCallbacks[MAX_SUPPORTED_ADAPTERS];
 484     mbedtls_x509_crl crl;
 485     bool cipherFlag[2];
 486     int selectedCipher;
 487
 488 #ifdef __WITH_DTLS__
 489     mbedtls_ssl_cookie_ctx cookieCtx;
 490     int timerId;
 491 #endif
 492 } SslContext_t;
 493
 494 /**
 495  * @var g_caSslContext
 496  * @brief global context which holds tls context and cache list information.
 497  */
 498 static SslContext_t * g_caSslContext = NULL;
 499
 500 static SslExportKeysCallback_t gTlsExportKeysCallback = NULL;
 501
 502 static SslExportKeysCallback_t gDtlsExportKeysCallback = NULL;
 503
 504 /**
 505  * @var g_getCredentialsCallback
 506  * @brief callback to get TLS credentials (same as for DTLS)
 507  */
 508 static CAgetPskCredentialsHandler g_getCredentialsCallback = NULL;
 509 /**
 510  * @var g_getCerdentilTypesCallback
 511  * @brief callback to get different credential types from SRM
 512  */
 513 static CAgetCredentialTypesHandler g_getCredentialTypesCallback = NULL;
 514 /**
 515  * @var g_getPkixInfoCallback
 516  *
 517  * @brief callback to get X.509-based Public Key Infrastructure
 518  */
 519 static CAgetPkixInfoHandler g_getPkixInfoCallback = NULL;
 520
 521 /**
 522  * @var g_setupPkContextCallback
 523  *
 524  * @brief callback to setup PK context handler for H/W based Public Key Infrastructure
 525  */
 526 static CAsetupPkContextHandler g_setupPkContextCallback = NULL;
 527
 528 /**
 529  * @var g_dtlsContextMutex
 530  * @brief Mutex to synchronize access to g_caSslContext.
 531  */
 532 static oc_mutex g_sslContextMutex = NULL;
 533
 534 /**
 535  * @var g_sslCallback
 536  * @brief callback to deliver the TLS handshake result
 537  */
 538 static CAErrorCallback g_sslCallback = NULL;
 539
 540 /**
 541  * Data structure for PeerCertCallback.
 542  */
 543 typedef struct
 544 {
 545     PeerCertCallback cb;
 546     void *ctx;
 547 } PeerCertCallback_t;
 548
 549 /**
 550  * @var g_peerCertCallback
 551  *
 552  * @brief callback to utilize peer certificate information
 553  */
 554 static PeerCertCallback_t g_peerCertCallback = {NULL, NULL};
 555
 556 /**
 557  * @var g_decryptBuffer
 558  * @brief decrypt buffer which will be used for decryption
 559  */
 560 static uint8_t *g_decryptBuffer = NULL;
 561
 562 /**
 563  * Data structure for holding the data to be received.
 564  */
 565 typedef struct SslRecBuf
 566 {
 567     uint8_t * buff;
 568     size_t len;
 569     size_t loaded;
 570 } SslRecBuf_t;
 571 /**
 572  * Data structure for holding the data related to endpoint
 573  * and TLS session.
 574  */
 575 typedef struct SslEndPoint
 576 {
 577     mbedtls_ssl_context ssl;
 578     CASecureEndpoint_t sep;
 579     u_arraylist_t * cacheList;
 580     SslRecBuf_t recBuf;
 581     uint8_t master[MASTER_SECRET_LEN];
 582     uint8_t random[2*RANDOM_LEN];
 583 #ifdef __WITH_DTLS__
 584     mbedtls_timing_delay_context timer;
 585 #endif // __WITH_DTLS__
 586 } SslEndPoint_t;
 587
 588 void CAsetPskCredentialsCallback(CAgetPskCredentialsHandler credCallback)
 589 {
 590     // TODO Does this method needs protection of tlsContextMutex?
 591     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 592     g_getCredentialsCallback = credCallback;
 593     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 594 }
 595
 596 void CAsetPkixInfoCallback(CAgetPkixInfoHandler infoCallback)
 597 {
 598     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 599     g_getPkixInfoCallback = infoCallback;
 600     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 601 }
 602
 603 void CAsetSetupPkContextCallback(CAsetupPkContextHandler setupPkCtxCallback)
 604 {
 605     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 606     g_setupPkContextCallback = setupPkCtxCallback;
 607     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 608 }
 609
 610 void CAsetCredentialTypesCallback(CAgetCredentialTypesHandler credTypesCallback)
 611 {
 612     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 613     g_getCredentialTypesCallback = credTypesCallback;
 614     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 615 }
 616
 617 static int GetAdapterIndex(CATransportAdapter_t adapter)
 618 {
 619     switch (adapter)
 620     {
 621         case CA_ADAPTER_IP:
 622             return 0;
 623         case CA_ADAPTER_TCP:
 624             return 1;
 625         case CA_ADAPTER_GATT_BTLE:
 626             return 2;
 627         default:
 628             OIC_LOG(ERROR, NET_SSL_TAG, "Unsupported adapter");
 629             return -1;
 630     }
 631 }
 632 /**
 633  * Write callback.
 634  *
 635  * @param[in]  tep    TLS endpoint
 636  * @param[in]  data    message
 637  * @param[in]  dataLen    message length
 638  *
 639  * @return  message length or -1 on error.
 640  */
 641 static int SendCallBack(void * tep, const unsigned char * data, size_t dataLen)
 642 {
 643     OIC_LOG_V(INFO, NET_SSL_TAG, "In %s", __func__);
 644     VERIFY_NON_NULL_RET(tep, NET_SSL_TAG, "secure endpoint is NULL", -1);
 645     VERIFY_NON_NULL_RET(data, NET_SSL_TAG, "data is NULL", -1);
 646     VERIFY_NON_NULL_RET(g_caSslContext, NET_SSL_TAG, "SSL Context is NULL", -1);
 647     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Data len: %zu", dataLen);
 648     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Adapter: %u", ((SslEndPoint_t * )tep)->sep.endpoint.adapter);
 649     ssize_t sentLen = 0;
 650     int adapterIndex = GetAdapterIndex(((SslEndPoint_t * )tep)->sep.endpoint.adapter);
 651     if (0 <= adapterIndex && MAX_SUPPORTED_ADAPTERS > adapterIndex)
 652     {
 653         CAPacketSendCallback sendCallback = g_caSslContext->adapterCallbacks[adapterIndex].sendCallback;
 654         sentLen = sendCallback(&(((SslEndPoint_t * )tep)->sep.endpoint), (const void *) data, dataLen);
 655         if (sentLen < 0)
 656         {
 657             OIC_LOG_V(ERROR, NET_SSL_TAG, "sendCallback() is Failed(%zd)", sentLen);
 658             return -1;
 659         }
 660         else if ((size_t)sentLen != dataLen)
 661         {
 662             OIC_LOG_V(DEBUG, NET_SSL_TAG,
 663                     "Packet was partially sent - total/sent/remained bytes : %zd/%zu/%lu",
 664                     sentLen, dataLen, (dataLen - sentLen));
 665         }
 666     }
 667     else
 668     {
 669         OIC_LOG(ERROR, NET_SSL_TAG, "Unsupported adapter");
 670         return -1;
 671     }
 672
 673     OIC_LOG_V(INFO, NET_SSL_TAG, "Out %s", __func__);
 674     return sentLen;
 675 }
 676 /**
 677  * Read callback.
 678  *
 679  * @param[in]  tep    TLS endpoint
 680  * @param[in]  data    message
 681  * @param[in]  dataLen    message length
 682  *
 683  * @return  read length
 684  */
 685 static int RecvCallBack(void * tep, unsigned char * data, size_t dataLen)
 686 {
 687     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 688     VERIFY_NON_NULL_RET(tep, NET_SSL_TAG, "endpoint is NULL", 0);
 689     VERIFY_NON_NULL_RET(data, NET_SSL_TAG, "data is NULL", 0);
 690
 691     SslRecBuf_t *recBuf = &((SslEndPoint_t *)tep)->recBuf;
 692     size_t retLen = (recBuf->len > recBuf->loaded ? recBuf->len - recBuf->loaded : 0);
 693     retLen = (retLen < dataLen ? retLen : dataLen);
 694
 695     memcpy(data, recBuf->buff + recBuf->loaded, retLen);
 696     recBuf->loaded += retLen;
 697
 698     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 699     return (int)retLen;
 700 }
 701
 702 static int CASslExportKeysHandler(void *p_expkey,
 703                                 const unsigned char *ms,
 704                                 const unsigned char *kb,
 705                                 size_t maclen,
 706                                 size_t keylen,
 707                                 size_t ivlen)
 708 {
 709     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 710
 711     if (NULL == g_caSslContext)
 712     {
 713         OIC_LOG(ERROR, NET_SSL_TAG, "SSL Context is not initialized.");
 714         return MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
 715     }
 716     if (NULL == p_expkey)
 717     {
 718         OIC_LOG(ERROR, NET_SSL_TAG, "Can not find the protocol information from 'p_expkey'.");
 719         return MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
 720     }
 721
 722     CASslEkcbProtocol_t* protocol = (CASslEkcbProtocol_t*)p_expkey;
 723
 724     if (gTlsExportKeysCallback && CA_SSL_EKCB_TLS == (*protocol))
 725     {
 726         OIC_LOG(DEBUG, NET_SSL_TAG, "Invoking TLS export key callback.");
 727         gTlsExportKeysCallback(ms, kb, maclen, keylen, ivlen);
 728     }
 729     else if (gDtlsExportKeysCallback && CA_SSL_EKCB_DTLS == (*protocol))
 730     {
 731         OIC_LOG(DEBUG, NET_SSL_TAG, "Invoking DTLS export key callback.");
 732         gDtlsExportKeysCallback(ms, kb, maclen, keylen, ivlen);
 733     }
 734     else
 735     {
 736         OIC_LOG(ERROR, NET_SSL_TAG, "Failed to Invoke (D)TLS export key callback.");
 737         return MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
 738     }
 739
 740     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 741     return 0;
 742 }
 743
 744 CAResult_t CASetSslExportKeysCallback(SslExportKeysCallback_t exportKeysCb,
 745                                       CASslEkcbProtocol_t protocol, CASslEkcbRole_t role)
 746 {
 747     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 748     mbedtls_ssl_config* sslConf = NULL;
 749     static CASslEkcbProtocol_t protocolCtx = CA_SSL_EKCB_TLS;
 750
 751     if (CA_SSL_EKCB_TLS != protocol && CA_SSL_EKCB_DTLS != protocol)
 752     {
 753         OIC_LOG(ERROR, NET_SSL_TAG, "Invaild protocol.");
 754         return CA_STATUS_INVALID_PARAM;
 755     }
 756     if (CA_SSL_EKCB_CLIENT != role && CA_SSL_EKCB_SERVER != role)
 757     {
 758         OIC_LOG(ERROR, NET_SSL_TAG, "Invaild role.");
 759         return CA_STATUS_INVALID_PARAM;
 760     }
 761
 762     OIC_LOG_V(DEBUG, NET_SSL_TAG, "TLS Export Key Callback Type : [%s] [%s]",
 763               (CA_SSL_EKCB_TLS == protocol ? "TLS" : "DTLS"),
 764               (CA_SSL_EKCB_CLIENT == role ? "Client" : "Server"));
 765
 766     oc_mutex_lock(g_sslContextMutex);
 767     if (NULL == g_caSslContext)
 768     {
 769         OIC_LOG(ERROR, NET_SSL_TAG, "SSL Context is not initialized.");
 770         oc_mutex_unlock(g_sslContextMutex);
 771         return CA_STATUS_NOT_INITIALIZED;
 772     }
 773
 774     if (CA_SSL_EKCB_TLS == protocol)
 775     {
 776         gTlsExportKeysCallback = exportKeysCb;
 777         if (CA_SSL_EKCB_CLIENT == role)
 778         {
 779             sslConf = &g_caSslContext->clientTlsConf;
 780         }
 781         else
 782         {
 783             sslConf = &g_caSslContext->serverTlsConf;
 784         }
 785     }
 786     else
 787     {
 788         gDtlsExportKeysCallback = exportKeysCb;
 789         if (CA_SSL_EKCB_CLIENT == role)
 790         {
 791             sslConf = &g_caSslContext->clientDtlsConf;
 792         }
 793         else
 794         {
 795             sslConf = &g_caSslContext->serverDtlsConf;
 796         }
 797     }
 798     protocolCtx = protocol;
 799
 800     if (NULL == exportKeysCb)
 801     {
 802         mbedtls_ssl_conf_export_keys_cb(sslConf, NULL, NULL);
 803         OIC_LOG(DEBUG, NET_SSL_TAG, "Export key callback unregistered.");
 804     }
 805     else
 806     {
 807         mbedtls_ssl_conf_export_keys_cb(sslConf, CASslExportKeysHandler, (void*)(&protocolCtx));
 808         OIC_LOG(DEBUG, NET_SSL_TAG, "Export key callback registered.");
 809     }
 810     oc_mutex_unlock(g_sslContextMutex);
 811
 812     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 813
 814     return CA_STATUS_OK;
 815 }
 816
 817 /**
 818  * Parse chain of X.509 certificates.
 819  *
 820  * @param[out] crt     container for X.509 certificates
 821  * @param[in]  data    buffer with X.509 certificates. Certificates may be in either in PEM
 822                        or DER format in a jumble, delimiting symbols does not matter.
 823  * @param[in]  bufLen  buffer length
 824  * @param[in]  errNum  number certificates that failed to parse
 825  *
 826  * @return  number of successfully parsed certificates or -1 on error
 827  */
 828 static int ParseChain(mbedtls_x509_crt * crt, unsigned char * buf, size_t bufLen, int * errNum)
 829 {
 830     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
 831     VERIFY_NON_NULL_RET(crt, NET_SSL_TAG, "Param crt is NULL" , -1);
 832     VERIFY_NON_NULL_RET(buf, NET_SSL_TAG, "Param buf is NULL" , -1);
 833
 834     char pemCertHeader[] = {
 835         0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x43, 0x45, 0x52,
 836         0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d
 837     };
 838     char pemCertFooter[] = {
 839         0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x45, 0x4e, 0x44, 0x20, 0x43, 0x45, 0x52, 0x54, 0x49,
 840         0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d
 841     };
 842     size_t pemCertHeaderLen = sizeof(pemCertHeader);
 843     size_t pemCertFooterLen = sizeof(pemCertFooter);
 844
 845     size_t len = 0;
 846     unsigned char * tmp = NULL;
 847     int count = 0;
 848     int ret = 0;
 849     size_t pos = 0;
 850
 851     *errNum = 0;
 852     while (pos < bufLen)
 853     {
 854         if (buf[pos] == 0x30 && buf[pos + 1] == 0x82)
 855         {
 856             tmp = (unsigned char *)buf + pos + 1;
 857             CHECK_MBEDTLS_RET(mbedtls_asn1_get_len, &tmp, buf + bufLen, &len);
 858             if (pos + len < bufLen)
 859             {
 860                 ret = mbedtls_x509_crt_parse_der(crt, buf + pos, len + 4);
 861                 if (0 == ret)
 862                 {
 863                     count++;
 864                 }
 865                 else
 866                 {
 867                     (*errNum)++;
 868                     OIC_LOG_V(ERROR, NET_SSL_TAG, "mbedtls_x509_crt_parse_der returned -0x%04x\n", -(ret));
 869                 }
 870             }
 871             pos += len + 4;
 872         }
 873         else if ((buf + pos + pemCertHeaderLen < buf + bufLen) &&
 874                  (0 == memcmp(buf + pos, pemCertHeader, pemCertHeaderLen)))
 875         {
 876             void * endPos = NULL;
 877             endPos = memmem(&(buf[pos]), bufLen - pos, pemCertFooter, pemCertFooterLen);
 878             if (NULL == endPos)
 879             {
 880                 OIC_LOG(ERROR, NET_SSL_TAG, "Error: end of PEM certificate not found.");
 881                 OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 882                 return -1;
 883             }
 884             len = (char*)endPos - ((char*)buf + pos) + pemCertFooterLen;
 885             if (pos + len + 1 <= bufLen)
 886             {
 887                 char con = buf[pos + len];
 888                 buf[pos + len] = 0x00;
 889                 ret = mbedtls_x509_crt_parse(crt, buf + pos, len + 1);
 890                 if (0 == ret)
 891                 {
 892                     count++;
 893                 }
 894                 else
 895                 {
 896                     (*errNum)++;
 897                     OIC_LOG_V(ERROR, NET_SSL_TAG, "mbedtls_x509_crt_parse returned -0x%04x\n", -(ret));
 898                 }
 899                 buf[pos + len] = con;
 900             }
 901             else
 902             {
 903                 unsigned char * lastCert = (unsigned char *)OICMalloc((len + 1) * sizeof(unsigned char));
 904                 memcpy(lastCert, buf + pos, len);
 905                 lastCert[len] = 0x00;
 906                 ret = mbedtls_x509_crt_parse(crt, lastCert, len + 1);
 907                 if (0 == ret)
 908                 {
 909                     count++;
 910                 }
 911                 else
 912                 {
 913                     (*errNum)++;
 914                     OIC_LOG_V(ERROR, NET_SSL_TAG, "mbedtls_x509_crt_parse returned -0x%04x\n", -(ret));
 915                 }
 916                 OICFree(lastCert);
 917             }
 918             pos += len;
 919         }
 920         else
 921         {
 922             pos++;
 923         }
 924     }
 925     OIC_LOG_V(INFO, NET_SSL_TAG, "%s successfully parsed %d certificates", __func__, count);
 926     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
 927     return count;
 928
 929 exit:
 930     return -1;
 931 }
 932
 933 static int VerifyCertificateCallback(void *p_vrfy, mbedtls_x509_crt *crt, int depth,
 934         uint32_t *flags)
 935 {
 936     (void)p_vrfy;
 937     char buf[1024] = {0};
 938
 939     if (0 != *flags) // Invalid Cerificate
 940     {
 941         int ret;
 942         ret = mbedtls_x509_crt_verify_info(buf, sizeof(buf), "", *flags);
 943         if (0 < ret)
 944         {
 945             OIC_LOG_V(ERROR, NET_SSL_TAG, "%s(%d)", buf, *flags);
 946         }
 947         return 1;
 948     }
 949
 950     if (NULL == g_peerCertCallback.cb)
 951     {
 952         OIC_LOG(DEBUG, NET_SSL_TAG, "NOT SET g_peerCertCallback");
 953         return 0;
 954     }
 955
 956     /*
 957      * e.g.
 958      * depth = 0 : Own Cert.
 959      * depth = 1 : Sub CA Cert.
 960      * depth = 2 : Root CA Cert.
 961      */
 962     OIC_LOG_V(INFO, NET_SSL_TAG, "Depth : %d", depth);
 963
 964     mbedtls_x509_crt_info(buf, sizeof(buf) - 1, "", crt);
 965     OIC_LOG_V(DEBUG, NET_SSL_TAG, "crt : %s", buf);
 966
 967     return g_peerCertCallback.cb(g_peerCertCallback.ctx, crt, depth);
 968 }
 969
 970 CAResult_t CAsetPeerCertCallback(void *ctx, PeerCertCallback peerCertCallback)
 971 {
 972 #ifndef __WITH_DTLS__
 973     UNUSED(ctx);
 974     UNUSED(peerCertCallback);
 975     OIC_LOG(ERROR, NET_SSL_TAG, "Not Supported");
 976     return CA_NOT_SUPPORTED;
 977 #endif
 978
 979     if (peerCertCallback)
 980     {
 981         OIC_LOG(DEBUG, NET_SSL_TAG, "SET peerCertCallback");
 982         g_peerCertCallback.cb = peerCertCallback;
 983         g_peerCertCallback.ctx = ctx;
 984     }
 985     else
 986     {
 987         OIC_LOG(DEBUG, NET_SSL_TAG, "UNSET peerCertCallback");
 988         g_peerCertCallback.cb = NULL;
 989         g_peerCertCallback.ctx = NULL;
 990     }
 991     return CA_STATUS_OK;
 992 }
 993
 994 //Loads PKIX related information from SRM
 995 static int InitPKIX(CATransportAdapter_t adapter)
 996 {
 997     OIC_LOG_V(INFO, NET_SSL_TAG, "In %s", __func__);
 998     VERIFY_NON_NULL_RET(g_getPkixInfoCallback, NET_SSL_TAG, "PKIX info callback is NULL", -1);
 999     VERIFY_NON_NULL_RET(g_caSslContext, NET_SSL_TAG, "SSL Context is NULL", -1);
1000
1001     mbedtls_x509_crt_free(&g_caSslContext->ca);
1002     mbedtls_x509_crt_free(&g_caSslContext->crt);
1003     mbedtls_pk_free(&g_caSslContext->pkey);
1004     mbedtls_x509_crl_free(&g_caSslContext->crl);
1005
1006     mbedtls_x509_crt_init(&g_caSslContext->ca);
1007     mbedtls_x509_crt_init(&g_caSslContext->crt);
1008     mbedtls_pk_init(&g_caSslContext->pkey);
1009     mbedtls_x509_crl_init(&g_caSslContext->crl);
1010
1011     mbedtls_ssl_config * serverConf = (adapter == CA_ADAPTER_IP ||
1012                                    adapter == CA_ADAPTER_GATT_BTLE ?
1013                                    &g_caSslContext->serverDtlsConf : &g_caSslContext->serverTlsConf);
1014     mbedtls_ssl_config * clientConf = (adapter == CA_ADAPTER_IP ||
1015                                    adapter == CA_ADAPTER_GATT_BTLE ?
1016                                    &g_caSslContext->clientDtlsConf : &g_caSslContext->clientTlsConf);
1017
1018 #ifdef __WITH_DTLS__
1019     /*
1020      * Conf. is initialized in CAinitSslAdapter()
1021      */
1022     mbedtls_ssl_conf_verify(&g_caSslContext->clientDtlsConf, VerifyCertificateCallback, NULL);
1023 #endif
1024
1025     // load pk key, cert, trust chain and crl
1026     if (g_getPkixInfoCallback)
1027     {
1028         OIC_LOG(INFO, NET_SSL_TAG, "g_getPkixInfoCallback will be invoked");
1029         g_getPkixInfoCallback(&g_pkiInfo);
1030     }
1031
1032     // parse own certficate (optional)
1033     int ret;
1034     int errNum;
1035     int count = ParseChain(&g_caSslContext->crt, g_pkiInfo.crt.data, g_pkiInfo.crt.len, &errNum);
1036     if (0 >= count)
1037     {
1038         OIC_LOG(WARNING, NET_SSL_TAG, "Own certificate chain parsing error");
1039         goto required;
1040     }
1041     if (0 != errNum)
1042     {
1043         OIC_LOG_V(WARNING, NET_SSL_TAG, "Own certificate chain parsing error: %d certs failed to parse", errNum);
1044         goto required;
1045     }
1046
1047     // parse private key if hw is not supported (optional)
1048     if(NULL == g_setupPkContextCallback)
1049     {
1050         OIC_LOG(INFO, NET_SSL_TAG, "g_setupPkContextCallback is NULL");
1051         ret =  mbedtls_pk_parse_key(&g_caSslContext->pkey, g_pkiInfo.key.data, g_pkiInfo.key.len,
1052                                                                                    NULL, 0);
1053     }
1054     else
1055     {
1056         OIC_LOG(INFO, NET_SSL_TAG, "g_setupPkContextCallback will be invoked");
1057         // setup hw pk context (optional)
1058         ret = g_setupPkContextCallback(&g_caSslContext->pkey);
1059         if (0 == ret)
1060         {
1061             // setup public parameter
1062             mbedtls_pk_type_t ktype = mbedtls_pk_get_type(&g_caSslContext->pkey);
1063             if (MBEDTLS_PK_ECKEY == ktype || MBEDTLS_PK_ECKEY_DH == ktype
1064                 || MBEDTLS_PK_ECDSA == ktype)
1065             {
1066                 OIC_LOG_V(DEBUG, NET_SSL_TAG, "Copy ecp public param from cert, keytype [%d]", ktype);
1067                 mbedtls_ecp_keypair *eckey = (mbedtls_ecp_keypair*)g_caSslContext->crt.pk.pk_ctx;
1068                 mbedtls_ecdsa_context *ecdsa = (mbedtls_ecdsa_context*)g_caSslContext->pkey.pk_ctx;
1069                 if (ecdsa && eckey)
1070                 {
1071                     ret = mbedtls_ecdsa_from_keypair(ecdsa, eckey);
1072                     if(0 != ret )
1073                     {
1074                         OIC_LOG_V(ERROR, NET_SSL_TAG, "Fail to copy public param [0x%x]", ret);
1075                     }
1076                 }
1077                 else
1078                 {
1079                     OIC_LOG_V(WARNING, NET_SSL_TAG, "key-ctx(%p), cert-ctx(%p)", ecdsa, eckey);
1080                     goto required;
1081                 }
1082             }
1083             else
1084             {
1085                 OIC_LOG_V(INFO, NET_SSL_TAG, "loaded key is not one of eckey type [%d]", ktype);
1086             }
1087         }
1088         else
1089         {
1090             OIC_LOG_V(ERROR, NET_SSL_TAG, "Fail to call g_setupPkContextCallback [%d]", ret);
1091         }
1092     }
1093     if (0 != ret)
1094     {
1095         OIC_LOG(WARNING, NET_SSL_TAG, "Key parsing error");
1096         goto required;
1097     }
1098
1099     ret = mbedtls_ssl_conf_own_cert(serverConf, &g_caSslContext->crt, &g_caSslContext->pkey);
1100     if (0 != ret)
1101     {
1102         OIC_LOG(WARNING, NET_SSL_TAG, "Own certificate parsing error");
1103         goto required;
1104     }
1105     ret = mbedtls_ssl_conf_own_cert(clientConf, &g_caSslContext->crt, &g_caSslContext->pkey);
1106     if(0 != ret)
1107     {
1108         OIC_LOG(WARNING, NET_SSL_TAG, "Own certificate configuration error");
1109         goto required;
1110     }
1111
1112     required:
1113     count = ParseChain(&g_caSslContext->ca, g_pkiInfo.ca.data, g_pkiInfo.ca.len, &errNum);
1114     if(0 >= count)
1115     {
1116         OIC_LOG(WARNING, NET_SSL_TAG, "CA chain in svr db was not parsed");
1117         OIC_LOG(WARNING, NET_SSL_TAG, "    but if working as server, chain not required");
1118         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1119         return -1;
1120     }
1121     if(0 != errNum)
1122     {
1123         OIC_LOG_V(WARNING, NET_SSL_TAG, "CA chain parsing warning: %d certs failed to parse", errNum);
1124     }
1125
1126     ret = mbedtls_x509_crl_parse_der(&g_caSslContext->crl, g_pkiInfo.crl.data, g_pkiInfo.crl.len);
1127     if(0 != ret)
1128     {
1129         OIC_LOG(WARNING, NET_SSL_TAG, "CRL in svr db was not parsed");
1130         CONF_SSL(clientConf, serverConf, mbedtls_ssl_conf_ca_chain, &g_caSslContext->ca, NULL);
1131     }
1132     else
1133     {
1134         CONF_SSL(clientConf, serverConf, mbedtls_ssl_conf_ca_chain,
1135                  &g_caSslContext->ca, &g_caSslContext->crl);
1136     }
1137
1138     OIC_LOG_V(INFO, NET_SSL_TAG, "Out %s", __func__);
1139     return 0;
1140 }
1141
1142 /*
1143  * PSK callback.
1144  *
1145  * @param[in]  notUsed     opaque context
1146  * @param[in]  ssl    mbedTLS context
1147  * @param[in]  desc    identity
1148  * @param[in]  descLen    identity length
1149  *
1150  * @return  0 on success any other return value will result in a denied PSK identity
1151  */
1152 static int GetPskCredentialsCallback(void * notUsed, mbedtls_ssl_context * ssl,
1153                                      const unsigned char * desc, size_t descLen)
1154 {
1155     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1156     VERIFY_NON_NULL_RET(g_getCredentialsCallback, NET_SSL_TAG, "Credential callback s NULL", -1);
1157     VERIFY_NON_NULL_RET(ssl, NET_SSL_TAG, "ssl pointer is NULL", -1);
1158     VERIFY_NON_NULL_RET(desc, NET_SSL_TAG, "desc pointer is NULL", -1);
1159     if (descLen > CA_MAX_ENDPOINT_IDENTITY_LEN)
1160     {
1161         OIC_LOG(ERROR, NET_SSL_TAG, "desc too long!");
1162         return -1;
1163     }
1164     (void) notUsed;
1165     uint8_t keyBuf[PSK_LENGTH] = {0};
1166
1167     // Retrieve the credentials blob from security module
1168     int ret = g_getCredentialsCallback(CA_DTLS_PSK_KEY, desc, descLen, keyBuf, PSK_LENGTH);
1169     if (ret > 0)
1170     {
1171         memcpy(((SslEndPoint_t *) ssl)->sep.identity.id, desc, descLen);
1172         ((SslEndPoint_t *) ssl)->sep.identity.id_length = descLen;
1173         OIC_LOG(DEBUG, NET_SSL_TAG, "PSK:");
1174         OIC_LOG_BUFFER(DEBUG, NET_SSL_TAG, keyBuf, ret);
1175
1176         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1177         return(mbedtls_ssl_set_hs_psk(ssl, keyBuf, ret));
1178     }
1179     OIC_LOG_V(WARNING, NET_SSL_TAG, "Out %s", __func__);
1180     return -1;
1181 }
1182
1183 /**
1184  * Gets session corresponding for endpoint.
1185  *
1186  * @param[in]  peer    remote address
1187  *
1188  * @return  TLS session or NULL
1189  */
1190 static SslEndPoint_t *GetSslPeer(const CAEndpoint_t *peer)
1191 {
1192     uint32_t listIndex = 0;
1193     uint32_t listLength = 0;
1194     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1195     VERIFY_NON_NULL_RET(peer, NET_SSL_TAG, "TLS peer is NULL", NULL);
1196     VERIFY_NON_NULL_RET(g_caSslContext, NET_SSL_TAG, "SSL Context is NULL", NULL);
1197
1198     SslEndPoint_t *tep = NULL;
1199     listLength = u_arraylist_length(g_caSslContext->peerList);
1200     for (listIndex = 0; listIndex < listLength; listIndex++)
1201     {
1202         tep = (SslEndPoint_t *) u_arraylist_get(g_caSslContext->peerList, listIndex);
1203         if (NULL == tep)
1204         {
1205             continue;
1206         }
1207
1208         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Compare [%s:%d] and [%s:%d] for %d adapter",
1209                   peer->addr, peer->port, tep->sep.endpoint.addr, tep->sep.endpoint.port,
1210                   peer->adapter);
1211
1212         if((peer->adapter == tep->sep.endpoint.adapter)
1213                 && (0 == strncmp(peer->addr, tep->sep.endpoint.addr, MAX_ADDR_STR_SIZE_CA))
1214                 && (peer->port == tep->sep.endpoint.port || CA_ADAPTER_GATT_BTLE == peer->adapter))
1215         {
1216             OIC_LOG_V(DEBUG, NET_SSL_TAG, "Found Peer:[%s:%d] for %d adapter",
1217                     peer->addr, peer->port, peer->adapter);
1218             OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1219             return tep;
1220         }
1221     }
1222     OIC_LOG_V(INFO, NET_SSL_TAG, "Peer not found:[%s:%d] for %d adapter",
1223             peer->addr, peer->port, peer->adapter);
1224     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1225     return NULL;
1226 }
1227
1228 bool CAIsExistSslPeer(const CAEndpoint_t *peer)
1229 {
1230     oc_mutex_lock(g_sslContextMutex);
1231     if (NULL == g_caSslContext)
1232     {
1233         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
1234         oc_mutex_unlock(g_sslContextMutex);
1235         return false;
1236     }
1237
1238     if (GetSslPeer(peer))
1239     {
1240         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Exist Peer");
1241         oc_mutex_unlock(g_sslContextMutex);
1242         return true;
1243     }
1244     else
1245     {
1246         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Not Exist Peer");
1247         oc_mutex_unlock(g_sslContextMutex);
1248         return false;
1249     }
1250 }
1251
1252 /**
1253  * Gets session corresponding for endpoint.
1254  *
1255  * @param[in]  peer    remote address
1256  *
1257  * @return  TLS session or NULL
1258  */
1259 static SslEndPoint_t *GetSslPeerUsingUuid(const uint8_t *identity, size_t idLength)
1260 {
1261     uint32_t listIndex = 0;
1262     uint32_t listLength = 0;
1263     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1264     VERIFY_NON_NULL_RET(identity, NET_SSL_TAG, "Param identity is NULL", NULL);
1265     VERIFY_NON_NULL_RET(g_caSslContext, NET_SSL_TAG, "SSL Context is NULL", NULL);
1266
1267     OIC_LOG(INFO, NET_SSL_TAG, "[Target UUID]");
1268     OIC_LOG_BUFFER(INFO, NET_SSL_TAG, identity, idLength);
1269
1270     SslEndPoint_t *tep = NULL;
1271     listLength = u_arraylist_length(g_caSslContext->peerList);
1272     for (listIndex = 0; listIndex < listLength; listIndex++)
1273     {
1274         tep = (SslEndPoint_t *) u_arraylist_get(g_caSslContext->peerList, listIndex);
1275         if (NULL == tep)
1276         {
1277             continue;
1278         }
1279
1280         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Compare UUID for [%s:%d]",
1281                   tep->sep.endpoint.addr, tep->sep.endpoint.port);
1282
1283         if ((tep->sep.identity.id_length == idLength)
1284             && (0 == memcmp(identity, tep->sep.identity.id, idLength)))
1285         {
1286             OIC_LOG_V(INFO, NET_SSL_TAG, "Found matched UUID in [%s:%d]",
1287                       tep->sep.endpoint.addr, tep->sep.endpoint.port);
1288             OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1289             return tep;
1290         }
1291     }
1292     OIC_LOG(INFO, NET_SSL_TAG, "Peer not found");
1293     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1294     return NULL;
1295 }
1296
1297
1298 #ifdef MULTIPLE_OWNER
1299 /**
1300  * Gets CA secure endpoint info corresponding for endpoint.
1301  *
1302  * @param[in]  peer    remote address
1303  *
1304  * @return  CASecureEndpoint or NULL
1305  */
1306 const CASecureEndpoint_t *GetCASecureEndpointData(const CAEndpoint_t* peer)
1307 {
1308     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1309
1310     // TODO: Added as workaround, need to debug
1311     oc_mutex_unlock(g_sslContextMutex);
1312
1313     oc_mutex_lock(g_sslContextMutex);
1314     if (NULL == g_caSslContext)
1315     {
1316         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
1317         oc_mutex_unlock(g_sslContextMutex);
1318         return NULL;
1319     }
1320
1321     SslEndPoint_t* sslPeer = GetSslPeer(peer);
1322     if(sslPeer)
1323     {
1324         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1325         oc_mutex_unlock(g_sslContextMutex);
1326         return &sslPeer->sep;
1327     }
1328
1329     OIC_LOG(DEBUG, NET_SSL_TAG, "Return NULL");
1330     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1331     oc_mutex_unlock(g_sslContextMutex);
1332     return NULL;
1333 }
1334 #endif
1335
1336 /**
1337  * Deletes cached message.
1338  *
1339  * @param[in]  msg    message
1340  */
1341 static void DeleteCacheMessage(SslCacheMessage_t * msg)
1342 {
1343     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1344     VERIFY_NON_NULL_VOID(msg, NET_SSL_TAG, "msg");
1345
1346     OICFree(msg->data);
1347     OICFree(msg);
1348
1349     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1350 }
1351 /**
1352  * Deletes cached message list.
1353  *
1354  * @param[in] cacheList  list of cached messages
1355  */
1356 static void DeleteCacheList(u_arraylist_t * cacheList)
1357 {
1358     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1359     VERIFY_NON_NULL_VOID(cacheList, NET_SSL_TAG, "cacheList");
1360     uint32_t listIndex = 0;
1361     uint32_t listLength = 0;
1362
1363     listLength = u_arraylist_length(cacheList);
1364     for (listIndex = 0; listIndex < listLength; listIndex++)
1365     {
1366         SslCacheMessage_t * msg = (SslCacheMessage_t *) u_arraylist_get(cacheList, listIndex);
1367         if (NULL != msg)
1368         {
1369             DeleteCacheMessage(msg);
1370         }
1371     }
1372     u_arraylist_free(&cacheList);
1373
1374     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1375 }
1376 /**
1377  * Deletes endpoint with session.
1378  *
1379  * @param[in]  tep    endpoint with session info
1380  */
1381 static void DeleteSslEndPoint(SslEndPoint_t * tep)
1382 {
1383     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1384     VERIFY_NON_NULL_VOID(tep, NET_SSL_TAG, "tep");
1385
1386     mbedtls_ssl_free(&tep->ssl);
1387     DeleteCacheList(tep->cacheList);
1388     OICFree(tep);
1389     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1390 }
1391 /**
1392  * Removes endpoint session from list.
1393  *
1394  * @param[in]  endpoint    remote address
1395  */
1396 static void RemovePeerFromList(const CAEndpoint_t * endpoint)
1397 {
1398     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1399     VERIFY_NON_NULL_VOID(g_caSslContext, NET_SSL_TAG, "SSL Context is NULL");
1400     VERIFY_NON_NULL_VOID(endpoint, NET_SSL_TAG, "endpoint");
1401     uint32_t listLength = u_arraylist_length(g_caSslContext->peerList);
1402     for (uint32_t listIndex = 0; listIndex < listLength; listIndex++)
1403     {
1404         SslEndPoint_t * tep = (SslEndPoint_t *)u_arraylist_get(g_caSslContext->peerList,listIndex);
1405         if (NULL == tep)
1406         {
1407             continue;
1408         }
1409         if(0 == strncmp(endpoint->addr, tep->sep.endpoint.addr, MAX_ADDR_STR_SIZE_CA)
1410                 && (endpoint->port == tep->sep.endpoint.port || CA_ADAPTER_GATT_BTLE == endpoint->adapter))
1411         {
1412             u_arraylist_remove(g_caSslContext->peerList, listIndex);
1413             OIC_LOG_V(INFO, NET_SSL_TAG, "Remove Peer:[%s:%d] for %d adapter",
1414                     endpoint->addr, endpoint->port, endpoint->adapter);
1415             DeleteSslEndPoint(tep);
1416             OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1417             return;
1418         }
1419     }
1420     OIC_LOG_V(INFO, NET_SSL_TAG, "Peer not found:[%s:%d] for %d adapter",
1421             endpoint->addr, endpoint->port, endpoint->adapter);
1422     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1423 }
1424 /**
1425  * Deletes session list.
1426  */
1427 static void DeletePeerList()
1428 {
1429     OIC_LOG_V(DEBUG, NET_SSL_TAG, "%s", __func__);
1430     VERIFY_NON_NULL_VOID(g_caSslContext, NET_SSL_TAG, "SSL Context is NULL");
1431
1432     uint32_t listLength = u_arraylist_length(g_caSslContext->peerList);
1433     for (uint32_t listIndex = 0; listIndex < listLength; listIndex++)
1434     {
1435         SslEndPoint_t * tep = (SslEndPoint_t *)u_arraylist_get(g_caSslContext->peerList,listIndex);
1436         if (NULL == tep)
1437         {
1438             continue;
1439         }
1440         if (MBEDTLS_SSL_HANDSHAKE_OVER == tep->ssl.state)
1441         {
1442             int ret = 0;
1443             do
1444             {
1445                 ret = mbedtls_ssl_close_notify(&tep->ssl);
1446             }
1447             while (MBEDTLS_ERR_SSL_WANT_WRITE == ret);
1448         }
1449         DeleteSslEndPoint(tep);
1450     }
1451     u_arraylist_free(&g_caSslContext->peerList);
1452 }
1453
1454 CAResult_t CAcloseSslConnection(const CAEndpoint_t *endpoint)
1455 {
1456     OIC_LOG_V(INFO, NET_SSL_TAG, "In %s", __func__);
1457     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG, "Param endpoint is NULL" , CA_STATUS_INVALID_PARAM);
1458
1459     oc_mutex_lock(g_sslContextMutex);
1460     if (NULL == g_caSslContext)
1461     {
1462         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
1463         oc_mutex_unlock(g_sslContextMutex);
1464         return CA_STATUS_FAILED;
1465     }
1466     SslEndPoint_t * tep = GetSslPeer(endpoint);
1467     if (NULL == tep)
1468     {
1469         OIC_LOG(ERROR, NET_SSL_TAG, "Session does not exist");
1470         oc_mutex_unlock(g_sslContextMutex);
1471         return CA_STATUS_FAILED;
1472     }
1473     /* No error checking, the connection might be closed already */
1474     int ret = 0;
1475     do
1476     {
1477         ret = mbedtls_ssl_close_notify(&tep->ssl);
1478     }
1479     while (MBEDTLS_ERR_SSL_WANT_WRITE == ret);
1480
1481     RemovePeerFromList(&tep->sep.endpoint);
1482     oc_mutex_unlock(g_sslContextMutex);
1483
1484     OIC_LOG_V(INFO, NET_SSL_TAG, "Out %s", __func__);
1485     return CA_STATUS_OK;
1486 }
1487
1488 CAResult_t CAcloseSslConnectionUsingUuid(const uint8_t *identity, size_t idLength)
1489 {
1490     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1491     VERIFY_NON_NULL_RET(identity, NET_SSL_TAG, "Param identity is NULL" , CA_STATUS_INVALID_PARAM);
1492
1493     oc_mutex_lock(g_sslContextMutex);
1494     if (NULL == g_caSslContext)
1495     {
1496         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
1497         oc_mutex_unlock(g_sslContextMutex);
1498         return CA_STATUS_FAILED;
1499     }
1500
1501     SslEndPoint_t* tep = GetSslPeerUsingUuid(identity, idLength);
1502     if (NULL == tep)
1503     {
1504         OIC_LOG(ERROR, NET_SSL_TAG, "Session does not exist");
1505         oc_mutex_unlock(g_sslContextMutex);
1506         return CA_STATUS_FAILED;
1507     }
1508
1509     /* No error checking, the connection might be closed already */
1510     int ret = 0;
1511     do
1512     {
1513         ret = mbedtls_ssl_close_notify(&tep->ssl);
1514     }
1515     while (MBEDTLS_ERR_SSL_WANT_WRITE == ret);
1516
1517     RemovePeerFromList(&tep->sep.endpoint);
1518     oc_mutex_unlock(g_sslContextMutex);
1519
1520     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1521     return CA_STATUS_OK;
1522 }
1523
1524 void CAcloseSslConnectionAll(CATransportAdapter_t transportType)
1525 {
1526     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1527     oc_mutex_lock(g_sslContextMutex);
1528     if (NULL == g_caSslContext)
1529     {
1530         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
1531         oc_mutex_unlock(g_sslContextMutex);
1532         return;
1533     }
1534
1535     uint32_t listLength = u_arraylist_length(g_caSslContext->peerList);
1536     OIC_LOG_V(INFO, NET_SSL_TAG,
1537             "Required transport [%d], peer count [%d]", transportType, listLength);
1538     for (uint32_t i = listLength; i > 0; i--)
1539     {
1540         SslEndPoint_t *tep = (SslEndPoint_t *)u_arraylist_get(g_caSslContext->peerList, i - 1);
1541         if (NULL == tep)
1542         {
1543             continue;
1544         }
1545         OIC_LOG_V(INFO, NET_SSL_TAG, "SSL Connection [%s:%d], Transport [%d]",
1546                   tep->sep.endpoint.addr, tep->sep.endpoint.port, tep->sep.endpoint.adapter);
1547
1548         // check transport matching
1549         if (0 == (tep->sep.endpoint.adapter & transportType))
1550         {
1551             OIC_LOG(DEBUG, NET_SSL_TAG, "Skip the un-matched transport session");
1552             continue;
1553         }
1554
1555         // TODO: need to check below code after socket close is ensured.
1556         /*int ret = 0;
1557         do
1558         {
1559             ret = mbedtls_ssl_close_notify(&tep->ssl);
1560         }
1561         while (MBEDTLS_ERR_SSL_WANT_WRITE == ret);*/
1562
1563         // delete from list
1564         u_arraylist_remove(g_caSslContext->peerList, i - 1);
1565         DeleteSslEndPoint(tep);
1566     }
1567     oc_mutex_unlock(g_sslContextMutex);
1568
1569     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1570     return;
1571 }
1572 /**
1573  * Creates session for endpoint.
1574  *
1575  * @param[in]  endpoint    remote address
1576  * @param[in]  config    mbedTLS configuration info
1577  *
1578  * @return  TLS endpoint or NULL
1579  */
1580 static SslEndPoint_t * NewSslEndPoint(const CAEndpoint_t * endpoint, mbedtls_ssl_config * config)
1581 {
1582     SslEndPoint_t * tep = NULL;
1583     OIC_LOG_V(INFO, NET_SSL_TAG, "In %s", __func__);
1584     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG, "endpoint", NULL);
1585     VERIFY_NON_NULL_RET(config, NET_SSL_TAG, "config", NULL);
1586     VERIFY_NON_NULL_RET(g_caSslContext, NET_SSL_TAG, "SSL Context is NULL", NULL);
1587
1588     tep = (SslEndPoint_t *) OICCalloc(1, sizeof (SslEndPoint_t));
1589     if (NULL == tep)
1590     {
1591         OIC_LOG(ERROR, NET_SSL_TAG, "Malloc failed!");
1592         return NULL;
1593     }
1594
1595     tep->sep.endpoint = *endpoint;
1596     tep->sep.endpoint.flags = (CATransportFlags_t)(tep->sep.endpoint.flags | CA_SECURE);
1597
1598     if(0 != mbedtls_ssl_setup(&tep->ssl, config))
1599     {
1600         OIC_LOG(ERROR, NET_SSL_TAG, "Setup failed");
1601         OICFree(tep);
1602         OIC_LOG_V(INFO, NET_SSL_TAG, "Out %s", __func__);
1603         return NULL;
1604     }
1605
1606     mbedtls_ssl_set_bio(&tep->ssl, tep, SendCallBack, RecvCallBack, NULL);
1607     if (MBEDTLS_SSL_TRANSPORT_DATAGRAM == config->transport)
1608     {
1609         mbedtls_ssl_set_timer_cb(&tep->ssl, &tep->timer,
1610                                   mbedtls_timing_set_delay, mbedtls_timing_get_delay);
1611         if (MBEDTLS_SSL_IS_SERVER == config->endpoint)
1612         {
1613             if (0 != mbedtls_ssl_set_client_transport_id(&tep->ssl,
1614                                     (const unsigned char *) endpoint->addr, sizeof(endpoint->addr)))
1615             {
1616                 OIC_LOG(ERROR, NET_SSL_TAG, "Transport id setup failed!");
1617                 mbedtls_ssl_free(&tep->ssl);
1618                 OICFree(tep);
1619                 OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1620                 return NULL;
1621             }
1622         }
1623     }
1624     tep->cacheList = u_arraylist_create();
1625     if (NULL == tep->cacheList)
1626     {
1627         OIC_LOG(ERROR, NET_SSL_TAG, "cacheList initialization failed!");
1628         mbedtls_ssl_free(&tep->ssl);
1629         OICFree(tep);
1630         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1631         return NULL;
1632     }
1633     OIC_LOG_V(INFO, NET_SSL_TAG, "New [%s role] endpoint added [%s:%d]",
1634             (MBEDTLS_SSL_IS_SERVER==config->endpoint ? "server" : "client"),
1635             endpoint->addr, endpoint->port);
1636     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1637     return tep;
1638 }
1639 /**
1640  * Initializes PSK identity.
1641  *
1642  * @param[out]  config    client/server config to be updated
1643  *
1644  * @return  0 on success or -1 on error
1645  */
1646 static int InitPskIdentity(mbedtls_ssl_config * config)
1647 {
1648     uint8_t keyBuf[PSK_LENGTH] = {0};
1649     uint8_t idBuf[UUID_LENGTH] = {0};
1650     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1651     VERIFY_NON_NULL_RET(config, NET_SSL_TAG, "Param config is NULL" , -1);
1652
1653     //Retrieve PSK identity from SVR DB
1654     if (0 > g_getCredentialsCallback(CA_DTLS_PSK_IDENTITY, NULL, 0, idBuf, UUID_LENGTH))
1655     {
1656         OIC_LOG(ERROR, NET_SSL_TAG, "Identity not found");
1657         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1658         return -1;
1659     }
1660     //Store PSK ideneity in mbedtls_ssl_config
1661     if (0 != mbedtls_ssl_conf_psk(config, keyBuf, PSK_LENGTH, idBuf, UUID_LENGTH))
1662     {
1663         OIC_LOG(ERROR, NET_SSL_TAG, "Identity initialization failed!");
1664         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1665         return -1;
1666     }
1667     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1668     return 0;
1669 }
1670 static void SetupCipher(mbedtls_ssl_config * config, CATransportAdapter_t adapter)
1671 {
1672     int index = 0;
1673     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1674     VERIFY_NON_NULL_VOID(config, NET_SSL_TAG, "Invaild param");
1675     VERIFY_NON_NULL_VOID(g_caSslContext, NET_SSL_TAG, "SSL Context is NULL");
1676     VERIFY_NON_NULL_VOID(g_getCredentialTypesCallback, NET_SSL_TAG, "Param callback is null");
1677
1678     //Resetting cipherFlag
1679     g_caSslContext->cipherFlag[0] = false;
1680     g_caSslContext->cipherFlag[1] = false;
1681
1682     g_getCredentialTypesCallback(g_caSslContext->cipherFlag);
1683     // Retrieve the PSK credential from SRM
1684     if (0 != InitPskIdentity(config))
1685     {
1686         OIC_LOG(ERROR, NET_SSL_TAG, "PSK identity initialization failed!");
1687     }
1688
1689     // Retrieve the Cert credential from SRM
1690     if (true == g_caSslContext->cipherFlag[1])
1691     {
1692         int ret = InitPKIX(adapter);
1693         if (0 != ret)
1694         {
1695             OIC_LOG(ERROR, NET_SSL_TAG, "Failed to init X.509");
1696         }
1697     }
1698
1699     memset(g_cipherSuitesList, 0, sizeof(g_cipherSuitesList));
1700
1701     if (SSL_CIPHER_MAX < g_caSslContext->cipher)
1702     {
1703         OIC_LOG(ERROR, NET_SSL_TAG, "Maximum ciphersuite index exceeded");
1704     }
1705
1706     // Add the preferred ciphersuite first
1707     if (SSL_CIPHER_MAX != g_caSslContext->cipher)
1708     {
1709         g_cipherSuitesList[index] = tlsCipher[g_caSslContext->cipher][0];
1710         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Preferred ciphersuite added");
1711         index++;
1712     }
1713
1714     // Add PSK ciphersuite
1715     if (true == g_caSslContext->cipherFlag[0] &&
1716                 SSL_CIPHER_MAX != g_caSslContext->cipher &&
1717                 MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 != tlsCipher[g_caSslContext->cipher][0])
1718     {
1719        g_cipherSuitesList[index] = MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256;
1720        OIC_LOG(DEBUG, NET_SSL_TAG, "PSK ciphersuite added");
1721        index++;
1722     }
1723
1724     // Add all certificate ciphersuites
1725     if (true == g_caSslContext->cipherFlag[1])
1726     {
1727         for (unsigned int i = 0; i < SSL_CIPHER_MAX - 1; i++)
1728         {
1729             if (MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 != tlsCipher[i][0] &&
1730                 i != g_caSslContext->cipher)
1731             {
1732                 g_cipherSuitesList[index] = tlsCipher[i][0];
1733                 index ++;
1734             }
1735         }
1736
1737         if (MBEDTLS_SSL_IS_SERVER == config->endpoint)
1738         {
1739             mbedtls_ssl_conf_authmode(config, MBEDTLS_SSL_VERIFY_OPTIONAL);
1740         }
1741     }
1742
1743     OIC_LOG(INFO, NET_SSL_TAG, "Supported ciphersuites:");
1744     for (int i = 0; i < index; i++)
1745     {
1746         OIC_LOG_V(INFO, NET_SSL_TAG, "Ciphersuite %04x", g_cipherSuitesList[i]);
1747     }
1748
1749     mbedtls_ssl_conf_ciphersuites(config, g_cipherSuitesList);
1750
1751     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1752 }
1753 /**
1754  * Initiate TLS handshake with endpoint.
1755  *
1756  * @param[in]  endpoint    remote address
1757  *
1758  * @return  TLS endpoint or NULL
1759  */
1760 static SslEndPoint_t * InitiateTlsHandshake(const CAEndpoint_t *endpoint)
1761 {
1762     int ret = 0;
1763     SslEndPoint_t * tep = NULL;
1764
1765     OIC_LOG_V(INFO, NET_SSL_TAG, "In %s", __func__);
1766     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG, "Param endpoint is NULL" , NULL);
1767     VERIFY_NON_NULL_RET(g_caSslContext, NET_SSL_TAG, "SSL Context is NULL", NULL);
1768
1769     //Remove previous peer info from peer list.
1770     RemovePeerFromList(endpoint);
1771
1772     mbedtls_ssl_config * config = (endpoint->adapter == CA_ADAPTER_IP ||
1773                                    endpoint->adapter == CA_ADAPTER_GATT_BTLE ?
1774                                    &g_caSslContext->clientDtlsConf : &g_caSslContext->clientTlsConf);
1775     tep = NewSslEndPoint(endpoint, config);
1776     if (NULL == tep)
1777     {
1778         OIC_LOG(ERROR, NET_SSL_TAG, "Malloc failed!");
1779         return NULL;
1780     }
1781
1782     //Load allowed SVR suites from SVR DB
1783     SetupCipher(config, endpoint->adapter);
1784
1785     ret = u_arraylist_add(g_caSslContext->peerList, (void *) tep);
1786     if (!ret)
1787     {
1788         OIC_LOG(ERROR, NET_SSL_TAG, "u_arraylist_add failed!");
1789         DeleteSslEndPoint(tep);
1790         return NULL;
1791     }
1792
1793     while (MBEDTLS_SSL_HANDSHAKE_OVER > tep->ssl.state)
1794     {
1795         ret = mbedtls_ssl_handshake_step(&tep->ssl);
1796         if (MBEDTLS_ERR_SSL_CONN_EOF == ret)
1797         {
1798             break;
1799         }
1800         else if (-1 == ret)
1801         {
1802             OIC_LOG(ERROR, NET_SSL_TAG, "Handshake failed due to socket error");
1803             RemovePeerFromList(&tep->sep.endpoint);
1804             return NULL;
1805         }
1806         SSL_CHECK_FAIL(tep, ret, "Handshake error", 0, NULL, MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE);
1807     }
1808     OIC_LOG_V(INFO, NET_SSL_TAG, "Out %s", __func__);
1809     return tep;
1810 }
1811 #ifdef __WITH_DTLS__
1812 /**
1813  * Stops DTLS retransmission.
1814  */
1815 static void StopRetransmit()
1816 {
1817     if (g_caSslContext)
1818     {
1819         unregisterTimer(g_caSslContext->timerId);
1820         g_caSslContext->timerId= -1;
1821     }
1822 }
1823 #endif
1824 void CAdeinitSslAdapter()
1825 {
1826     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1827
1828     VERIFY_NON_NULL_VOID(g_caSslContext, NET_SSL_TAG, "context is NULL");
1829     VERIFY_NON_NULL_VOID(g_sslContextMutex, NET_SSL_TAG, "context mutex is NULL");
1830
1831     //Lock tlsContext mutex
1832     oc_mutex_lock(g_sslContextMutex);
1833
1834     // Clear all lists
1835     DeletePeerList();
1836
1837     // De-initialize mbedTLS
1838     mbedtls_x509_crt_free(&g_caSslContext->ca);
1839     mbedtls_x509_crt_free(&g_caSslContext->crt);
1840     mbedtls_pk_free(&g_caSslContext->pkey);
1841     mbedtls_x509_crl_free(&g_caSslContext->crl);
1842 #ifdef __WITH_TLS__
1843     mbedtls_ssl_config_free(&g_caSslContext->clientTlsConf);
1844     mbedtls_ssl_config_free(&g_caSslContext->serverTlsConf);
1845 #endif // __WITH_TLS__
1846 #ifdef __WITH_DTLS__
1847     mbedtls_ssl_config_free(&g_caSslContext->clientDtlsConf);
1848     mbedtls_ssl_config_free(&g_caSslContext->serverDtlsConf);
1849     mbedtls_ssl_cookie_free(&g_caSslContext->cookieCtx);
1850 #endif // __WITH_DTLS__
1851     mbedtls_ctr_drbg_free(&g_caSslContext->rnd);
1852     mbedtls_entropy_free(&g_caSslContext->entropy);
1853 #ifdef __WITH_DTLS__
1854     StopRetransmit();
1855 #endif
1856     // De-initialize tls Context
1857     OICFree(g_caSslContext);
1858     g_caSslContext = NULL;
1859
1860     // Delete decrypt buffer
1861     if (g_decryptBuffer)
1862     {
1863         OICFree(g_decryptBuffer);
1864         g_decryptBuffer = NULL;
1865     }
1866
1867     // Unlock tlsContext mutex and de-initialize it
1868     oc_mutex_unlock(g_sslContextMutex);
1869     oc_mutex_free(g_sslContextMutex);
1870     g_sslContextMutex = NULL;
1871
1872     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s ", __func__);
1873 }
1874
1875 static int InitConfig(mbedtls_ssl_config * conf, int transport, int mode)
1876 {
1877     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1878     VERIFY_NON_NULL_RET(conf, NET_SSL_TAG, "Param conf is NULL" , -1);
1879     VERIFY_NON_NULL_RET(g_caSslContext, NET_SSL_TAG, "SSL Context is NULL", -1);
1880     mbedtls_ssl_config_init(conf);
1881     if (mbedtls_ssl_config_defaults(conf, mode, transport, MBEDTLS_SSL_PRESET_DEFAULT) != 0)
1882     {
1883         OIC_LOG(ERROR, NET_SSL_TAG, "Config initialization failed!");
1884         return -1;
1885     }
1886
1887     mbedtls_ssl_conf_psk_cb(conf, GetPskCredentialsCallback, NULL);
1888     mbedtls_ssl_conf_rng(conf, mbedtls_ctr_drbg_random, &g_caSslContext->rnd);
1889     mbedtls_ssl_conf_curves(conf, curve[ADAPTER_CURVE_SECP256R1]);
1890     mbedtls_ssl_conf_min_version(conf, MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3);
1891     mbedtls_ssl_conf_renegotiation(conf, MBEDTLS_SSL_RENEGOTIATION_DISABLED);
1892     mbedtls_ssl_conf_authmode(conf, MBEDTLS_SSL_VERIFY_REQUIRED);
1893     mbedtls_ssl_conf_sig_hashes(conf, g_ssl_ordered_default_hashes);
1894
1895 #ifdef __WITH_DTLS__
1896     if (MBEDTLS_SSL_TRANSPORT_DATAGRAM == transport &&
1897             MBEDTLS_SSL_IS_SERVER == mode)
1898     {
1899         mbedtls_ssl_conf_dtls_cookies(conf, mbedtls_ssl_cookie_write, mbedtls_ssl_cookie_check,
1900                                       &g_caSslContext->cookieCtx);
1901     }
1902 #endif // __WITH_DTLS__
1903
1904 #if !defined(NDEBUG) || defined(TB_LOG)
1905     mbedtls_ssl_conf_dbg(conf, DebugSsl, NULL);
1906     mbedtls_debug_set_threshold(MBED_TLS_DEBUG_LEVEL);
1907 #endif
1908     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1909     return 0;
1910 }
1911 #ifdef __WITH_DTLS__
1912 /**
1913  * Starts DTLS retransmission.
1914  */
1915 static int StartRetransmit()
1916 {
1917     uint32_t listIndex = 0;
1918     uint32_t listLength = 0;
1919     SslEndPoint_t *tep = NULL;
1920
1921     oc_mutex_lock(g_sslContextMutex);
1922     if (NULL == g_caSslContext)
1923     {
1924         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL. Stop retransmission");
1925         oc_mutex_unlock(g_sslContextMutex);
1926         return -1;
1927     }
1928     if (g_caSslContext->timerId != -1)
1929     {
1930         //clear previous timer
1931         unregisterTimer(g_caSslContext->timerId);
1932
1933         listLength = u_arraylist_length(g_caSslContext->peerList);
1934
1935         for (listIndex = 0; listIndex < listLength; listIndex++)
1936         {
1937             tep = (SslEndPoint_t *) u_arraylist_get(g_caSslContext->peerList, listIndex);
1938             if (NULL == tep
1939                 || (tep->ssl.conf && MBEDTLS_SSL_TRANSPORT_STREAM == tep->ssl.conf->transport)
1940                 || MBEDTLS_SSL_HANDSHAKE_OVER == tep->ssl.state)
1941             {
1942                 continue;
1943             }
1944             OIC_LOG_V(INFO, NET_SSL_TAG, "peer #%d", (int) listIndex);
1945
1946             int ret = mbedtls_ssl_handshake_step(&tep->ssl);
1947
1948             if (MBEDTLS_ERR_SSL_CONN_EOF != ret)
1949             {
1950                 //start new timer
1951                 registerTimer(RETRANSMISSION_TIME, &g_caSslContext->timerId, (void *) StartRetransmit);
1952                 //unlock & return
1953                 SSL_CHECK_FAIL(tep, ret, "Retransmission", 1, CA_STATUS_FAILED,
1954                 MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE);
1955             }
1956         }
1957     }
1958     //start new timer
1959     registerTimer(RETRANSMISSION_TIME, &g_caSslContext->timerId, (void *) StartRetransmit);
1960     oc_mutex_unlock(g_sslContextMutex);
1961
1962     return 0;
1963 }
1964 #endif
1965
1966 CAResult_t CAinitSslAdapter()
1967 {
1968     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1969     // Initialize mutex for tlsContext
1970     if (NULL == g_sslContextMutex)
1971     {
1972         g_sslContextMutex = oc_mutex_new();
1973         VERIFY_NON_NULL_RET(g_sslContextMutex, NET_SSL_TAG, "malloc failed", CA_MEMORY_ALLOC_FAILED);
1974     }
1975     else
1976     {
1977         OIC_LOG(INFO, NET_SSL_TAG, "Done already!");
1978         return CA_STATUS_OK;
1979     }
1980
1981     // Lock tlsContext mutex and create tlsContext
1982     oc_mutex_lock(g_sslContextMutex);
1983     g_caSslContext = (SslContext_t *)OICCalloc(1, sizeof(SslContext_t));
1984
1985     if (NULL == g_caSslContext)
1986     {
1987         OIC_LOG(ERROR, NET_SSL_TAG, "Context malloc failed");
1988         oc_mutex_unlock(g_sslContextMutex);
1989         oc_mutex_free(g_sslContextMutex);
1990         g_sslContextMutex = NULL;
1991         return CA_MEMORY_ALLOC_FAILED;
1992     }
1993
1994     // Create peer list
1995     g_caSslContext->peerList = u_arraylist_create();
1996
1997     if(NULL == g_caSslContext->peerList)
1998     {
1999         OIC_LOG(ERROR, NET_SSL_TAG, "peerList initialization failed!");
2000         OICFree(g_caSslContext);
2001         g_caSslContext = NULL;
2002         oc_mutex_unlock(g_sslContextMutex);
2003         oc_mutex_free(g_sslContextMutex);
2004         g_sslContextMutex = NULL;
2005         return CA_STATUS_FAILED;
2006     }
2007
2008     /* Initialize TLS library
2009      */
2010 #if !defined(NDEBUG) || defined(TB_LOG)
2011     char version[MBED_TLS_VERSION_LEN];
2012     mbedtls_version_get_string(version);
2013     OIC_LOG_V(INFO, NET_SSL_TAG, "mbed TLS version: %s", version);
2014 #endif
2015
2016     /* Entropy settings
2017      */
2018     mbedtls_entropy_init(&g_caSslContext->entropy);
2019     mbedtls_ctr_drbg_init(&g_caSslContext->rnd);
2020
2021 #ifdef __unix__
2022     unsigned char seed[sizeof(SEED)] = {0};
2023     int urandomFd = -2;
2024     urandomFd = open("/dev/urandom", O_RDONLY);
2025     if(urandomFd == -1)
2026     {
2027         OIC_LOG(ERROR, NET_SSL_TAG, "Fails open /dev/urandom!");
2028         oc_mutex_unlock(g_sslContextMutex);
2029         CAdeinitSslAdapter();
2030         return CA_STATUS_FAILED;
2031     }
2032     if(0 > read(urandomFd, seed, sizeof(seed)))
2033     {
2034         OIC_LOG(ERROR, NET_SSL_TAG, "Fails read from /dev/urandom!");
2035         close(urandomFd);
2036         oc_mutex_unlock(g_sslContextMutex);
2037         CAdeinitSslAdapter();
2038         return CA_STATUS_FAILED;
2039     }
2040     close(urandomFd);
2041
2042 #else
2043     unsigned char * seed = (unsigned char*) SEED;
2044 #endif
2045     if(0 != mbedtls_ctr_drbg_seed(&g_caSslContext->rnd, mbedtls_entropy_func,
2046                                   &g_caSslContext->entropy, seed, sizeof(SEED)))
2047     {
2048         OIC_LOG(ERROR, NET_SSL_TAG, "Seed initialization failed!");
2049         oc_mutex_unlock(g_sslContextMutex);
2050         CAdeinitSslAdapter();
2051         return CA_STATUS_FAILED;
2052     }
2053     mbedtls_ctr_drbg_set_prediction_resistance(&g_caSslContext->rnd, MBEDTLS_CTR_DRBG_PR_OFF);
2054
2055 #ifdef __WITH_TLS__
2056     if (0 != InitConfig(&g_caSslContext->clientTlsConf,
2057                         MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_IS_CLIENT))
2058     {
2059         OIC_LOG(ERROR, NET_SSL_TAG, "Client config initialization failed!");
2060         oc_mutex_unlock(g_sslContextMutex);
2061         CAdeinitSslAdapter();
2062         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2063         return CA_STATUS_FAILED;
2064     }
2065
2066     if (0 != InitConfig(&g_caSslContext->serverTlsConf,
2067                         MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_IS_SERVER))
2068     {
2069         OIC_LOG(ERROR, NET_SSL_TAG, "Server config initialization failed!");
2070         oc_mutex_unlock(g_sslContextMutex);
2071         CAdeinitSslAdapter();
2072         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2073         return CA_STATUS_FAILED;
2074     }
2075 #endif // __WITH_TLS__
2076 #ifdef __WITH_DTLS__
2077     mbedtls_ssl_cookie_init(&g_caSslContext->cookieCtx);
2078     if (0 != mbedtls_ssl_cookie_setup(&g_caSslContext->cookieCtx, mbedtls_ctr_drbg_random,
2079                                       &g_caSslContext->rnd))
2080     {
2081         OIC_LOG(ERROR, NET_SSL_TAG, "Cookie setup failed!");
2082         oc_mutex_unlock(g_sslContextMutex);
2083         CAdeinitSslAdapter();
2084         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2085         return CA_STATUS_FAILED;
2086     }
2087
2088     if (0 != InitConfig(&g_caSslContext->clientDtlsConf,
2089                         MBEDTLS_SSL_TRANSPORT_DATAGRAM, MBEDTLS_SSL_IS_CLIENT))
2090     {
2091         OIC_LOG(ERROR, NET_SSL_TAG, "Client config initialization failed!");
2092         oc_mutex_unlock(g_sslContextMutex);
2093         CAdeinitSslAdapter();
2094         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2095         return CA_STATUS_FAILED;
2096     }
2097
2098     if (0 != InitConfig(&g_caSslContext->serverDtlsConf,
2099                         MBEDTLS_SSL_TRANSPORT_DATAGRAM, MBEDTLS_SSL_IS_SERVER))
2100     {
2101         OIC_LOG(ERROR, NET_SSL_TAG, "Server config initialization failed!");
2102         oc_mutex_unlock(g_sslContextMutex);
2103         CAdeinitSslAdapter();
2104         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2105         return CA_STATUS_FAILED;
2106     }
2107 #endif // __WITH_DTLS__
2108
2109     // set default cipher
2110     g_caSslContext->cipher = SSL_CIPHER_MAX;
2111
2112     // init X.509
2113     mbedtls_x509_crt_init(&g_caSslContext->ca);
2114     mbedtls_x509_crt_init(&g_caSslContext->crt);
2115     mbedtls_pk_init(&g_caSslContext->pkey);
2116     mbedtls_x509_crl_init(&g_caSslContext->crl);
2117
2118 #ifdef __WITH_DTLS__
2119     g_caSslContext->timerId = -1;
2120 #endif
2121
2122     // create decrypt buffer
2123     g_decryptBuffer = (uint8_t *)OICCalloc(1, TLS_MSG_BUF_LEN);
2124     if (NULL == g_decryptBuffer)
2125     {
2126         OIC_LOG(ERROR, NET_SSL_TAG, "Decrypt buffer malloc failed");
2127         oc_mutex_unlock(g_sslContextMutex);
2128         CAdeinitSslAdapter();
2129         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2130         return CA_MEMORY_ALLOC_FAILED;
2131     }
2132
2133     oc_mutex_unlock(g_sslContextMutex);
2134 #ifdef __WITH_DTLS__
2135     StartRetransmit();
2136 #endif
2137
2138     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2139     return CA_STATUS_OK;
2140 }
2141
2142 SslCacheMessage_t *  NewCacheMessage(uint8_t * data, size_t dataLen)
2143 {
2144     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
2145     VERIFY_NON_NULL_RET(data, NET_SSL_TAG, "Param data is NULL" , NULL);
2146     if (0 == dataLen)
2147     {
2148         OIC_LOG(ERROR, NET_SSL_TAG, "dataLen is equal to zero");
2149         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2150         return NULL;
2151     }
2152     SslCacheMessage_t * message = (SslCacheMessage_t *) OICCalloc(1, sizeof(SslCacheMessage_t));
2153     if (NULL == message)
2154     {
2155         OIC_LOG(ERROR, NET_SSL_TAG, "calloc failed!");
2156         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2157         return NULL;
2158     }
2159
2160     message->data = (uint8_t *)OICCalloc(dataLen, sizeof(uint8_t));
2161     if (NULL == message->data)
2162     {
2163         OIC_LOG(ERROR, NET_SSL_TAG, "calloc failed!");
2164         OICFree(message);
2165         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2166         return NULL;
2167     }
2168     memcpy(message->data, data, dataLen);
2169     message->len = dataLen;
2170     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2171     return message;
2172 }
2173
2174 /* Send data via TLS connection.
2175  */
2176 CAResult_t CAencryptSsl(const CAEndpoint_t *endpoint,
2177                         void *data, uint32_t dataLen)
2178 {
2179     int ret = 0;
2180
2181     OIC_LOG_V(INFO, NET_SSL_TAG, "In %s ", __func__);
2182
2183     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG,"Remote address is NULL", CA_STATUS_INVALID_PARAM);
2184     VERIFY_NON_NULL_RET(data, NET_SSL_TAG, "Data is NULL", CA_STATUS_INVALID_PARAM);
2185     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Port %d", endpoint->port);
2186
2187     if (0 == dataLen)
2188     {
2189         OIC_LOG_V(ERROR, NET_SSL_TAG, "dataLen is zero [%d]", dataLen);
2190         return CA_STATUS_FAILED;
2191     }
2192
2193     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Data to be encrypted dataLen [%d]", dataLen);
2194
2195     oc_mutex_lock(g_sslContextMutex);
2196     if(NULL == g_caSslContext)
2197     {
2198         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
2199         oc_mutex_unlock(g_sslContextMutex);
2200         return CA_STATUS_FAILED;
2201     }
2202
2203     SslEndPoint_t * tep = GetSslPeer(endpoint);
2204     if (NULL == tep)
2205     {
2206         tep = InitiateTlsHandshake(endpoint);
2207     }
2208     if (NULL == tep)
2209     {
2210         OIC_LOG(ERROR, NET_SSL_TAG, "TLS handshake failed");
2211         oc_mutex_unlock(g_sslContextMutex);
2212         return CA_STATUS_FAILED;
2213     }
2214
2215     if (MBEDTLS_SSL_HANDSHAKE_OVER == tep->ssl.state)
2216     {
2217         OIC_LOG(INFO, NET_SSL_TAG, "(MBEDTLS_SSL_HANDSHAKE_OVER == tep->ssl.state)");
2218
2219         unsigned char *dataBuf = (unsigned char *)data;
2220         size_t written = 0;
2221
2222         do
2223         {
2224             ret = mbedtls_ssl_write(&tep->ssl, dataBuf, dataLen - written);
2225             if (ret < 0)
2226             {
2227                 if (MBEDTLS_ERR_SSL_WANT_WRITE != ret)
2228                 {
2229                     OIC_LOG_V(ERROR, NET_SSL_TAG, "mbedTLS write failed! returned 0x%x", -ret);
2230                     RemovePeerFromList(&tep->sep.endpoint);
2231                     oc_mutex_unlock(g_sslContextMutex);
2232                     return CA_STATUS_FAILED;
2233                 }
2234                 continue;
2235             }
2236             OIC_LOG_V(DEBUG, NET_SSL_TAG, "mbedTLS write returned with sent bytes[%d]", ret);
2237
2238             dataBuf += ret;
2239             written += ret;
2240         } while (dataLen > written);
2241
2242     }
2243     else
2244     {
2245         SslCacheMessage_t * msg = NewCacheMessage((uint8_t*) data, dataLen);
2246         if (NULL == msg || !u_arraylist_add(tep->cacheList, (void *) msg))
2247         {
2248             OIC_LOG(ERROR, NET_SSL_TAG, "u_arraylist_add failed!");
2249             oc_mutex_unlock(g_sslContextMutex);
2250             return CA_STATUS_FAILED;
2251         }
2252     }
2253
2254     oc_mutex_unlock(g_sslContextMutex);
2255
2256     OIC_LOG_V(INFO, NET_SSL_TAG, "Out %s", __func__);
2257     return CA_STATUS_OK;
2258 }
2259 /**
2260  * Sends cached messages via TLS connection.
2261  *
2262  * @param[in]  tep    remote address with session info
2263  */
2264 static void SendCacheMessages(SslEndPoint_t * tep)
2265 {
2266     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
2267     VERIFY_NON_NULL_VOID(tep, NET_SSL_TAG, "Param tep is NULL");
2268
2269     uint32_t listIndex = 0;
2270     uint32_t listLength = 0;
2271     listLength = u_arraylist_length(tep->cacheList);
2272     for (listIndex = 0; listIndex < listLength;)
2273     {
2274         int ret = 0;
2275         SslCacheMessage_t * msg = (SslCacheMessage_t *) u_arraylist_get(tep->cacheList, listIndex);
2276         if (NULL != msg && NULL != msg->data && 0 != msg->len)
2277         {
2278             unsigned char *dataBuf = (unsigned char *)msg->data;
2279             size_t written = 0;
2280
2281             do
2282             {
2283                 ret = mbedtls_ssl_write(&tep->ssl, dataBuf, msg->len - written);
2284                 if (ret < 0)
2285                 {
2286                     if (MBEDTLS_ERR_SSL_WANT_WRITE != ret)
2287                     {
2288                         OIC_LOG_V(ERROR, NET_SSL_TAG, "mbedTLS write failed! returned -0x%x", -ret);
2289                         break;
2290                     }
2291                     continue;
2292                 }
2293                 OIC_LOG_V(DEBUG, NET_SSL_TAG, "mbedTLS write returned with sent bytes[%d]", ret);
2294
2295                 dataBuf += ret;
2296                 written += ret;
2297             } while (msg->len > written);
2298
2299             if (u_arraylist_remove(tep->cacheList, listIndex))
2300             {
2301                 DeleteCacheMessage(msg);
2302                 // Reduce list length by 1 as we removed one element.
2303                 listLength--;
2304             }
2305             else
2306             {
2307                 OIC_LOG(ERROR, NET_SSL_TAG, "u_arraylist_remove failed.");
2308                 break;
2309             }
2310         }
2311         else
2312         {
2313             // Move to the next element
2314             ++listIndex;
2315         }
2316     }
2317     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2318 }
2319
2320 void CAsetSslHandshakeCallback(CAErrorCallback tlsHandshakeCallback)
2321 {
2322     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
2323     g_sslCallback = tlsHandshakeCallback;
2324     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2325 }
2326
2327 /* Read data from TLS connection
2328  */
2329 CAResult_t CAdecryptSsl(const CASecureEndpoint_t *sep, uint8_t *data, uint32_t dataLen)
2330 {
2331     int ret = 0;
2332     OIC_LOG_V(INFO, NET_SSL_TAG, "In %s", __func__);
2333     VERIFY_NON_NULL_RET(sep, NET_SSL_TAG, "endpoint is NULL" , CA_STATUS_INVALID_PARAM);
2334     VERIFY_NON_NULL_RET(data, NET_SSL_TAG, "Param data is NULL" , CA_STATUS_INVALID_PARAM);
2335
2336     oc_mutex_lock(g_sslContextMutex);
2337     if (NULL == g_caSslContext)
2338     {
2339         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
2340         oc_mutex_unlock(g_sslContextMutex);
2341         return CA_STATUS_FAILED;
2342     }
2343
2344
2345     SslEndPoint_t * peer = GetSslPeer(&sep->endpoint);
2346     if (NULL == peer)
2347     {
2348         mbedtls_ssl_config * config = (sep->endpoint.adapter == CA_ADAPTER_IP ||
2349                                    sep->endpoint.adapter == CA_ADAPTER_GATT_BTLE ?
2350                                    &g_caSslContext->serverDtlsConf : &g_caSslContext->serverTlsConf);
2351         peer = NewSslEndPoint(&sep->endpoint, config);
2352         if (NULL == peer)
2353         {
2354             OIC_LOG(ERROR, NET_SSL_TAG, "Malloc failed!");
2355             oc_mutex_unlock(g_sslContextMutex);
2356             return CA_STATUS_FAILED;
2357         }
2358         //Load allowed TLS suites from SVR DB
2359         SetupCipher(config, sep->endpoint.adapter);
2360
2361         ret = u_arraylist_add(g_caSslContext->peerList, (void *) peer);
2362         if (!ret)
2363         {
2364             OIC_LOG(ERROR, NET_SSL_TAG, "u_arraylist_add failed!");
2365             OICFree(peer);
2366             oc_mutex_unlock(g_sslContextMutex);
2367             return CA_STATUS_FAILED;
2368         }
2369     }
2370
2371     peer->recBuf.buff = data;
2372     peer->recBuf.len = dataLen;
2373     peer->recBuf.loaded = 0;
2374
2375     while (MBEDTLS_SSL_HANDSHAKE_OVER != peer->ssl.state)
2376     {
2377         ret = mbedtls_ssl_handshake_step(&peer->ssl);
2378         if (MBEDTLS_ERR_SSL_CONN_EOF == ret)
2379         {
2380             break;
2381         }
2382
2383         if (MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED == ret)
2384         {
2385             OIC_LOG(DEBUG, NET_SSL_TAG, "Hello verification requested");
2386             mbedtls_ssl_session_reset(&peer->ssl);
2387             mbedtls_ssl_set_client_transport_id(&peer->ssl,
2388                                                 (const unsigned char *) sep->endpoint.addr,
2389                                                  sizeof(sep->endpoint.addr));
2390             ret = mbedtls_ssl_handshake_step(&peer->ssl);
2391         }
2392         uint32_t flags = mbedtls_ssl_get_verify_result(&peer->ssl);
2393         if (0 != flags &&
2394            ((MBEDTLS_SSL_IS_CLIENT == peer->ssl.conf->endpoint) ||
2395             (MBEDTLS_SSL_IS_SERVER == peer->ssl.conf->endpoint && MBEDTLS_X509_BADCERT_MISSING != flags)))
2396         {
2397             OIC_LOG_BUFFER(ERROR, NET_SSL_TAG, (const uint8_t *) &flags, sizeof(flags));
2398             SSL_CHECK_FAIL(peer, flags, "Cert verification failed", 1,
2399                                                      CA_STATUS_FAILED, GetAlertCode(flags));
2400         }
2401         SSL_CHECK_FAIL(peer, ret, "Handshake error", 1, CA_STATUS_FAILED, MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE);
2402         if (MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC == peer->ssl.state)
2403         {
2404             memcpy(peer->master, peer->ssl.session_negotiate->master, sizeof(peer->master));
2405             g_caSslContext->selectedCipher = peer->ssl.session_negotiate->ciphersuite;
2406         }
2407         if (MBEDTLS_SSL_CLIENT_KEY_EXCHANGE == peer->ssl.state)
2408         {
2409             memcpy(peer->random, peer->ssl.handshake->randbytes, sizeof(peer->random));
2410         }
2411
2412         if (MBEDTLS_SSL_HANDSHAKE_OVER == peer->ssl.state)
2413         {
2414             SSL_RES(peer, CA_STATUS_OK);
2415             if (MBEDTLS_SSL_IS_CLIENT == peer->ssl.conf->endpoint)
2416             {
2417                 SendCacheMessages(peer);
2418             }
2419
2420             int selectedCipher = peer->ssl.session->ciphersuite;
2421             OIC_LOG_V(DEBUG, NET_SSL_TAG, "(D)TLS Session is connected via ciphersuite [0x%x]", selectedCipher);
2422             if (MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 != selectedCipher &&
2423                 MBEDTLS_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA256 != selectedCipher)
2424             {
2425                 char uuid[UUID_LENGTH * 2 + 5] = {0};
2426                 void * uuidPos = NULL;
2427                 void * userIdPos = NULL;
2428                 const mbedtls_x509_crt * peerCert = mbedtls_ssl_get_peer_cert(&peer->ssl);
2429                 ret = (NULL == peerCert ? -1 : 0);
2430                 //SSL_CHECK_FAIL(peer, ret, "Failed to retrieve cert", 1,
2431                 //                            CA_STATUS_FAILED, MBEDTLS_SSL_ALERT_MSG_NO_CERT);
2432                 if (0 == ret)
2433                 {
2434                     uuidPos = memmem(peerCert->subject_raw.p, peerCert->subject_raw.len,
2435                                                      UUID_PREFIX, sizeof(UUID_PREFIX) - 1);
2436
2437                     if (NULL != uuidPos)
2438                     {
2439                         memcpy(uuid, (char*) uuidPos + sizeof(UUID_PREFIX) - 1, UUID_LENGTH * 2 + 4);
2440                         OIC_LOG_V(DEBUG, NET_SSL_TAG, "certificate uuid string: %s" , uuid);
2441                         ret = OCConvertStringToUuid(uuid, peer->sep.identity.id);
2442                         SSL_CHECK_FAIL(peer, ret, "Failed to convert subject", 1,
2443                                               CA_STATUS_FAILED, MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT);
2444                     }
2445                     else
2446                     {
2447                         OIC_LOG(WARNING, NET_SSL_TAG, "uuid not found");
2448                     }
2449
2450                     userIdPos = memmem(peerCert->subject_raw.p, peerCert->subject_raw.len,
2451                                                  USERID_PREFIX, sizeof(USERID_PREFIX) - 1);
2452                     if (NULL != userIdPos)
2453                     {
2454                         memcpy(uuid, (char*) userIdPos + sizeof(USERID_PREFIX) - 1, UUID_LENGTH * 2 + 4);
2455                         ret = OCConvertStringToUuid(uuid, peer->sep.userId.id);
2456                         SSL_CHECK_FAIL(peer, ret, "Failed to convert subject alt name", 1,
2457                                           CA_STATUS_FAILED, MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT);
2458                     }
2459                     else
2460                     {
2461                         OIC_LOG(WARNING, NET_SSL_TAG, "Subject alternative name not found");
2462                     }
2463                 }
2464             }
2465
2466             if (MBEDTLS_SSL_IS_CLIENT == peer->ssl.conf->endpoint)
2467             {
2468                 SendCacheMessages(peer);
2469             }
2470             mbedtls_ssl_config * config = (sep->endpoint.adapter == CA_ADAPTER_IP ||
2471                                        sep->endpoint.adapter == CA_ADAPTER_GATT_BTLE ?
2472                                        &g_caSslContext->serverDtlsConf : &g_caSslContext->serverTlsConf);
2473
2474             mbedtls_ssl_conf_authmode(config, MBEDTLS_SSL_VERIFY_REQUIRED);
2475
2476             oc_mutex_unlock(g_sslContextMutex);
2477             OIC_LOG_V(INFO, NET_SSL_TAG, "Out %s", __func__);
2478             return CA_STATUS_OK;
2479         }
2480     }
2481
2482     if (MBEDTLS_SSL_HANDSHAKE_OVER == peer->ssl.state)
2483     {
2484         OIC_LOG(INFO, NET_SSL_TAG, "(MBEDTLS_SSL_HANDSHAKE_OVER == peer->ssl.state)");
2485
2486         // flag to read again remained data
2487         bool read_more = false;
2488         do
2489         {
2490             if (NULL == g_decryptBuffer)
2491             {
2492                 OIC_LOG(ERROR, NET_SSL_TAG, "decrypt buffer is NULL");
2493                 oc_mutex_unlock(g_sslContextMutex);
2494                 return CA_STATUS_FAILED;
2495             }
2496             memset(g_decryptBuffer, 0, TLS_MSG_BUF_LEN);
2497             read_more = false;
2498
2499             do
2500             {
2501                 ret = mbedtls_ssl_read(&peer->ssl, g_decryptBuffer, TLS_MSG_BUF_LEN);
2502             } while (MBEDTLS_ERR_SSL_WANT_READ == ret);
2503
2504             if (MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY == ret ||
2505                 // TinyDTLS sends fatal close_notify alert
2506                 (MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE == ret &&
2507                  MBEDTLS_SSL_ALERT_LEVEL_FATAL == peer->ssl.in_msg[0] &&
2508                  MBEDTLS_SSL_ALERT_MSG_CLOSE_NOTIFY == peer->ssl.in_msg[1]))
2509             {
2510                 OIC_LOG(INFO, NET_SSL_TAG, "Connection was closed gracefully");
2511                 RemovePeerFromList(&peer->sep.endpoint);
2512                 oc_mutex_unlock(g_sslContextMutex);
2513                 return CA_STATUS_OK;
2514             }
2515
2516             if (0 > ret)
2517             {
2518                 OIC_LOG_V(ERROR, NET_SSL_TAG, "mbedtls_ssl_read returned -0x%x", -ret);
2519                 //SSL_RES(peer, CA_STATUS_FAILED);
2520                 RemovePeerFromList(&peer->sep.endpoint);
2521                 oc_mutex_unlock(g_sslContextMutex);
2522                 return CA_STATUS_FAILED;
2523             }
2524             else if (0 < ret)
2525             {
2526                 int adapterIndex = GetAdapterIndex(peer->sep.endpoint.adapter);
2527                 if (0 <= adapterIndex && MAX_SUPPORTED_ADAPTERS > adapterIndex)
2528                 {
2529                     CAResult_t res;
2530                     res = g_caSslContext->adapterCallbacks[adapterIndex].recvCallback(&peer->sep,
2531                             g_decryptBuffer, ret);
2532                     if (CA_STATUS_OK != res)
2533                     {
2534                         OIC_LOG(ERROR, NET_SSL_TAG, "recvCallback is failed");
2535                         RemovePeerFromList(&peer->sep.endpoint);
2536                         oc_mutex_unlock(g_sslContextMutex);
2537                         return CA_STATUS_FAILED;
2538                     }
2539
2540                     // check if decrypted data is remained in stream transport
2541                     size_t remained = mbedtls_ssl_get_bytes_avail(&peer->ssl);
2542                     if (0 < remained &&
2543                         MBEDTLS_SSL_TRANSPORT_STREAM == peer->ssl.conf->transport)
2544                     {
2545                         OIC_LOG_V(DEBUG, NET_SSL_TAG, "need to read %zu bytes more", remained);
2546                         read_more = true;
2547                     }
2548                 }
2549                 else
2550                 {
2551                     OIC_LOG(ERROR, NET_SSL_TAG, "Unsuported adapter");
2552                     RemovePeerFromList(&peer->sep.endpoint);
2553                     oc_mutex_unlock(g_sslContextMutex);
2554                     return CA_STATUS_FAILED;
2555                 }
2556             }
2557         } while (read_more);
2558     }
2559
2560     oc_mutex_unlock(g_sslContextMutex);
2561     OIC_LOG_V(INFO, NET_SSL_TAG, "Out %s", __func__);
2562     return CA_STATUS_OK;
2563 }
2564
2565 void CAsetSslAdapterCallbacks(CAPacketReceivedCallback recvCallback,
2566                               CAPacketSendCallback sendCallback,
2567                               CATransportAdapter_t type)
2568 {
2569     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
2570     VERIFY_NON_NULL_VOID(sendCallback, NET_SSL_TAG, "sendCallback is NULL");
2571     VERIFY_NON_NULL_VOID(recvCallback, NET_SSL_TAG, "recvCallback is NULL");
2572     oc_mutex_lock(g_sslContextMutex);
2573     if (NULL == g_caSslContext)
2574     {
2575         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
2576         oc_mutex_unlock(g_sslContextMutex);
2577         return;
2578     }
2579
2580     switch (type)
2581     {
2582         case CA_ADAPTER_IP:
2583             g_caSslContext->adapterCallbacks[0].recvCallback = recvCallback;
2584             g_caSslContext->adapterCallbacks[0].sendCallback = sendCallback;
2585             break;
2586         case CA_ADAPTER_TCP:
2587             g_caSslContext->adapterCallbacks[1].recvCallback = recvCallback;
2588             g_caSslContext->adapterCallbacks[1].sendCallback = sendCallback;
2589             break;
2590         case CA_ADAPTER_GATT_BTLE:
2591             g_caSslContext->adapterCallbacks[2].recvCallback = recvCallback;
2592             g_caSslContext->adapterCallbacks[2].sendCallback = sendCallback;
2593             break;
2594         default:
2595             OIC_LOG_V(ERROR, NET_SSL_TAG, "Unsupported adapter: %d", type);
2596     }
2597
2598     oc_mutex_unlock(g_sslContextMutex);
2599     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2600 }
2601 /**
2602  * Gets index of the TLS ciphersuite in the SslCipher_t enum.
2603  *
2604  * @param[in]  cipher    TLS chiphersuite code
2605  *
2606  * @return   corresponding enum
2607  */
2608
2609 static SslCipher_t GetCipherIndex(const uint32_t cipher)
2610 {
2611     switch(cipher)
2612     {
2613         case MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA256:
2614         {
2615             return SSL_RSA_WITH_AES_256_CBC_SHA256;
2616         }
2617         case MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256:
2618         {
2619             return SSL_RSA_WITH_AES_128_GCM_SHA256;
2620         }
2621         case MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256:
2622         {
2623             return SSL_ECDHE_RSA_WITH_AES_128_GCM_SHA256;
2624         }
2625         case MBEDTLS_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384:
2626         {
2627             return SSL_ECDHE_RSA_WITH_AES_256_GCM_SHA384;
2628         }
2629         case MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256:
2630         {
2631             return SSL_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256;
2632         }
2633         case MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8:
2634         {
2635             return SSL_ECDHE_ECDSA_WITH_AES_128_CCM_8;
2636         }
2637         case MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM:
2638         {
2639             return SSL_ECDHE_ECDSA_WITH_AES_128_CCM;
2640         }
2641         case MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256:
2642         {
2643             return SSL_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256;
2644         }
2645         case MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384:
2646         {
2647             return SSL_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384;
2648         }
2649         case MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384:
2650         {
2651             return SSL_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384;
2652         }
2653         case MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256:
2654         {
2655             return SSL_ECDHE_PSK_WITH_AES_128_CBC_SHA256;
2656         }
2657         case MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256:
2658         {
2659             return SSL_ECDHE_RSA_WITH_AES_128_CBC_SHA256;
2660         }
2661         case MBEDTLS_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA256:
2662         {
2663             return SSL_ECDH_ANON_WITH_AES_128_CBC_SHA256;
2664         }
2665         default:
2666         {
2667             return SSL_CIPHER_MAX;
2668         }
2669     }
2670 }
2671
2672 CAResult_t CAsetTlsCipherSuite(const uint32_t cipher)
2673 {
2674     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
2675     VERIFY_NON_NULL_RET(g_caSslContext, NET_SSL_TAG, "SSL context is not initialized." , CA_STATUS_NOT_INITIALIZED);
2676
2677     SslCipher_t index = GetCipherIndex(cipher);
2678     if (SSL_CIPHER_MAX == index)
2679     {
2680         OIC_LOG(WARNING, NET_SSL_TAG, "Unknown cipher");
2681     }
2682     else
2683     {
2684 #ifdef __WITH_TLS__
2685         CONF_SSL(&g_caSslContext->clientTlsConf, &g_caSslContext->serverTlsConf,
2686         mbedtls_ssl_conf_ciphersuites, tlsCipher[index]);
2687 #endif
2688 #ifdef __WITH_DTLS__
2689         CONF_SSL(&g_caSslContext->clientDtlsConf, &g_caSslContext->serverDtlsConf,
2690         mbedtls_ssl_conf_ciphersuites, tlsCipher[index]);
2691 #endif
2692         OIC_LOG_V(INFO, NET_SSL_TAG, "Selected cipher: 0x%x", cipher);
2693     }
2694     g_caSslContext->cipher = index;
2695
2696     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2697     return CA_STATUS_OK;
2698 }
2699
2700 CAResult_t CAinitiateSslHandshake(const CAEndpoint_t *endpoint)
2701 {
2702     CAResult_t res = CA_STATUS_OK;
2703     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
2704     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG, "Param endpoint is NULL" , CA_STATUS_INVALID_PARAM);
2705     oc_mutex_lock(g_sslContextMutex);
2706     if (NULL == InitiateTlsHandshake(endpoint))
2707     {
2708         OIC_LOG(ERROR, NET_SSL_TAG, "TLS handshake failed");
2709         res = CA_STATUS_FAILED;
2710     }
2711     oc_mutex_unlock(g_sslContextMutex);
2712     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2713     return res;
2714 }
2715 /**
2716  * Expands the secret into blocks of data according
2717  * to the algorithm specified in section 5 of RFC 4346
2718  *
2719  * This function writes upto @p bufLen bytes into the given output buffer @p buf
2720  *
2721  * @param  key    secret key.
2722  * @param  keyLen    secret key length.
2723  * @param  label    A PRF label.
2724  * @param  labelLen     Actual length of @p label.
2725  * @param  random1    Random seed.
2726  * @param  random1Len     Actual length of @p random1 (may be zero).
2727  * @param  random2     Random seed.
2728  * @param  random2Len    Actual length of @p random2 (may be zero).
2729  * @param  buf    Output buffer for generated random data.
2730  * @param  bufLen    Maximum size of @p buf.
2731  *
2732  * @return The actual number of bytes written to @p buf or @c -1 on error.
2733  */
2734
2735 static int pHash (const unsigned char *key, size_t keyLen,
2736      const unsigned char *label, size_t labelLen,
2737      const unsigned char *random1, size_t random1Len,
2738      const unsigned char *random2, size_t random2Len,
2739      unsigned char *buf, size_t bufLen)
2740 {
2741     unsigned char A[RANDOM_LEN] = {0};
2742     unsigned char tmp[RANDOM_LEN] = {0};
2743     size_t dLen;   /* digest length */
2744     size_t len = 0;   /* result length */
2745
2746     VERIFY_NON_NULL_RET(key, NET_SSL_TAG, "key is NULL", -1);
2747     VERIFY_NON_NULL_RET(label, NET_SSL_TAG, "label is NULL", -1);
2748     VERIFY_NON_NULL_RET(random1, NET_SSL_TAG, "random1 is NULL", -1);
2749     VERIFY_NON_NULL_RET(random2, NET_SSL_TAG, "random2 is NULL", -1);
2750     VERIFY_NON_NULL_RET(buf, NET_SSL_TAG, "buf is NULL", -1);
2751
2752     mbedtls_md_context_t hmacA;
2753     mbedtls_md_context_t hmacP;
2754
2755     mbedtls_md_init(&hmacA);
2756     mbedtls_md_init(&hmacP);
2757
2758     CHECK_MBEDTLS_RET(mbedtls_md_setup, &hmacA, mbedtls_md_info_from_type(MBEDTLS_MD_SHA256), 1);
2759     CHECK_MBEDTLS_RET(mbedtls_md_setup, &hmacP, mbedtls_md_info_from_type(MBEDTLS_MD_SHA256), 1);
2760
2761     CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacA, key, keyLen );
2762     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacA, label, labelLen);
2763     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacA, random1, random1Len);
2764     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacA, random2, random2Len);
2765     CHECK_MBEDTLS_RET(mbedtls_md_hmac_finish, &hmacA, A);
2766
2767     dLen = RANDOM_LEN;
2768
2769     CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacP, key, keyLen);
2770
2771     while (len + dLen < bufLen)
2772     {
2773         CHECK_MBEDTLS_RET(mbedtls_md_hmac_reset, &hmacP);
2774         CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacP, key, keyLen);
2775         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, A, dLen);
2776         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, label, labelLen);
2777         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, random1, random1Len);
2778         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, random2, random2Len);
2779
2780         CHECK_MBEDTLS_RET(mbedtls_md_hmac_finish, &hmacP, tmp);
2781
2782         len += RANDOM_LEN;
2783
2784         memcpy(buf, tmp, dLen);
2785         buf += dLen;
2786
2787         CHECK_MBEDTLS_RET(mbedtls_md_hmac_reset, &hmacA);
2788         CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacA, key, keyLen);
2789         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacA, A, dLen);
2790         CHECK_MBEDTLS_RET(mbedtls_md_hmac_finish, &hmacA, A);
2791     }
2792
2793     CHECK_MBEDTLS_RET(mbedtls_md_hmac_reset, &hmacP);
2794     CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacP, key, keyLen);
2795     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, A, dLen);
2796
2797     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, label, labelLen);
2798     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, random1, random1Len);
2799     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, random2, random2Len);
2800     CHECK_MBEDTLS_RET(mbedtls_md_hmac_finish, &hmacP, tmp);
2801
2802     memcpy(buf, tmp, bufLen - len);
2803
2804     mbedtls_md_free(&hmacA);
2805     mbedtls_md_free(&hmacP);
2806     return bufLen;
2807
2808 exit:
2809     mbedtls_md_free(&hmacA);
2810     mbedtls_md_free(&hmacP);
2811     return -1;
2812 }
2813
2814 CAResult_t CAsslGenerateOwnerPsk(const CAEndpoint_t *endpoint,
2815                             const uint8_t* label, const size_t labelLen,
2816                             const uint8_t* rsrcServerDeviceId, const size_t rsrcServerDeviceIdLen,
2817                             const uint8_t* provServerDeviceId, const size_t provServerDeviceIdLen,
2818                             uint8_t* ownerPsk, const size_t ownerPskSize)
2819 {
2820     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
2821     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG, "endpoint is NULL", CA_STATUS_INVALID_PARAM);
2822     VERIFY_NON_NULL_RET(label, NET_SSL_TAG, "label is NULL", CA_STATUS_INVALID_PARAM);
2823     VERIFY_NON_NULL_RET(rsrcServerDeviceId, NET_SSL_TAG, "rsrcId is NULL", CA_STATUS_INVALID_PARAM);
2824     VERIFY_NON_NULL_RET(provServerDeviceId, NET_SSL_TAG, "provId is NULL", CA_STATUS_INVALID_PARAM);
2825     VERIFY_NON_NULL_RET(ownerPsk, NET_SSL_TAG, "ownerPSK is NULL", CA_STATUS_INVALID_PARAM);
2826
2827     oc_mutex_lock(g_sslContextMutex);
2828     if (NULL == g_caSslContext)
2829     {
2830         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
2831         oc_mutex_unlock(g_sslContextMutex);
2832         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2833         return CA_STATUS_FAILED;
2834     }
2835     SslEndPoint_t * tep = GetSslPeer(endpoint);
2836     if (NULL == tep)
2837     {
2838         OIC_LOG(ERROR, NET_SSL_TAG, "Session does not exist");
2839         oc_mutex_unlock(g_sslContextMutex);
2840         return CA_STATUS_FAILED;
2841     }
2842
2843     // keyBlockLen set up according to OIC 1.1 Security Specification Section 7.3.2
2844     int macKeyLen = 0;
2845     int ivSize = 0;
2846     int keySize = 0;
2847     int keyBlockLen = 0;
2848     if (MBEDTLS_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA256 == g_caSslContext->selectedCipher ||
2849         MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 == g_caSslContext->selectedCipher ||
2850         MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 == g_caSslContext->selectedCipher ||
2851         MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 == g_caSslContext->selectedCipher)
2852     {
2853         // 2 * ( 32 + 0 + 16 ) = 96
2854         macKeyLen = SHA256_MAC_KEY_LENGTH;
2855         ivSize = CBC_IV_LENGTH;
2856         keySize = AES128_KEY_LENGTH;
2857     }
2858     else if (MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM == g_caSslContext->selectedCipher ||
2859              MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8 == g_caSslContext->selectedCipher)
2860     {
2861         // 2 * ( 0 + 4 + 16 ) = 40
2862         macKeyLen = CCM_MAC_KEY_LENGTH;
2863         ivSize = CCM_IV_LENGTH;
2864         keySize = AES128_KEY_LENGTH;
2865     }
2866     else if (MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 == g_caSslContext->selectedCipher)
2867     {
2868         // 2 * ( 32 + 12 + 16 ) = 120
2869         macKeyLen = SHA256_MAC_KEY_LENGTH;
2870         ivSize = GCM_IV_LENGTH;
2871         keySize = AES128_KEY_LENGTH;
2872     }
2873     else if (MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA256 == g_caSslContext->selectedCipher)
2874     {
2875         // 2 * ( 32 + 0 + 32 ) = 128
2876         macKeyLen = SHA256_MAC_KEY_LENGTH;
2877         ivSize = CBC_IV_LENGTH;
2878         keySize = AES256_KEY_LENGTH;
2879     }
2880     else if (MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 == g_caSslContext->selectedCipher)
2881     {
2882         // 2 * ( 48 + 0 + 32 ) = 160
2883         macKeyLen = SHA384_MAC_KEY_LENGTH;
2884         ivSize = CBC_IV_LENGTH;
2885         keySize = AES256_KEY_LENGTH;
2886     }
2887     else if (MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 == g_caSslContext->selectedCipher)
2888     {
2889         // 2 * ( 48 + 12 + 32 ) = 184
2890         macKeyLen = SHA384_MAC_KEY_LENGTH;
2891         ivSize = GCM_IV_LENGTH;
2892         keySize = AES256_KEY_LENGTH;
2893     }
2894     else if (MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256 == g_caSslContext->selectedCipher)
2895     {
2896         // 2 * ( 48 + 12 + 32 ) = 184
2897         macKeyLen = SHA256_MAC_KEY_LENGTH;
2898         ivSize = GCM_IV_LENGTH;
2899         keySize = AES128_KEY_LENGTH;
2900     }
2901     keyBlockLen = 2 * (macKeyLen + keySize + ivSize);
2902
2903     uint8_t * keyblock = (uint8_t *)OICMalloc(keyBlockLen);
2904     if (NULL == keyblock)
2905     {
2906         OIC_LOG(ERROR, NET_SSL_TAG, "Failed to OICMalloc for keyblock");
2907         oc_mutex_unlock(g_sslContextMutex);
2908         return CA_STATUS_FAILED;
2909     }
2910
2911     // "key expansion"
2912     uint8_t lab[] = {0x6b, 0x65, 0x79, 0x20, 0x65, 0x78, 0x70, 0x61, 0x6e, 0x73, 0x69, 0x6f, 0x6e};
2913     int ret = pHash(tep->master, sizeof(tep->master), lab, sizeof(lab),
2914                     (tep->random) + RANDOM_LEN, RANDOM_LEN, tep->random, RANDOM_LEN,
2915                     keyblock, keyBlockLen);
2916     if (-1 == ret)
2917     {
2918         OIC_LOG(ERROR, NET_SSL_TAG, "PSK not generated");
2919         OICFree(keyblock);
2920         oc_mutex_unlock(g_sslContextMutex);
2921         return CA_STATUS_FAILED;
2922     }
2923
2924     ret = pHash(keyblock, keyBlockLen, label, labelLen,
2925                 rsrcServerDeviceId, rsrcServerDeviceIdLen,
2926                 provServerDeviceId, provServerDeviceIdLen,
2927                 ownerPsk, ownerPskSize);
2928     if (-1 == ret)
2929     {
2930         OIC_LOG(ERROR, NET_SSL_TAG, "PSK not generated");
2931         OICFree(keyblock);
2932         oc_mutex_unlock(g_sslContextMutex);
2933         return CA_STATUS_FAILED;
2934     }
2935
2936     OICFree(keyblock);
2937     oc_mutex_unlock(g_sslContextMutex);
2938
2939     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2940     return CA_STATUS_OK;
2941 }