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