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