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