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