4254b45455d618b1cd82f4b50a241a4f7f78abd5
[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
1363     if (NULL == crt || NULL == crt->raw.p)
1364     {
1365         return MBEDTLS_ERR_X509_BAD_INPUT_DATA;
1366     }
1367
1368     g_getIdentityCallback(&ctx, crt->raw.p, crt->raw.len);
1369     if (0 == depth) // leaf certificate
1370     {
1371         const mbedtls_x509_name * name = NULL;
1372         /* Find the CN component of the subject name. */
1373         for (name = &crt->subject; NULL != name; name = name->next)
1374         {
1375             if (name->oid.p &&
1376                (name->oid.len <= MBEDTLS_OID_SIZE(MBEDTLS_OID_AT_CN)) &&
1377                (0 == memcmp(MBEDTLS_OID_AT_CN, name->oid.p, name->oid.len)))
1378             {
1379                 break;
1380             }
1381         }
1382
1383         if (NULL == name)
1384         {
1385             OIC_LOG(ERROR, NET_SSL_TAG, "Could not retrieve identity information from leaf certificate");
1386             return -1;
1387         }
1388         const size_t uuidBufLen = UUID_STRING_SIZE - 1;
1389         const unsigned char * uuidPos = (const unsigned char*)memmem(name->val.p, name->val.len, UUID_PREFIX, sizeof(UUID_PREFIX) - 1);
1390         /* If UUID_PREFIX is present, ensure there's enough data for the prefix plus an entire
1391          * UUID, to make sure we don't read past the end of the buffer.
1392          */
1393         char uuid[UUID_STRING_SIZE] = { 0 };
1394         if ((NULL != uuidPos) && (name->val.len >= ((uuidPos - name->val.p) + (sizeof(UUID_PREFIX) - 1) + uuidBufLen)))
1395         {
1396             memcpy(uuid, uuidPos + sizeof(UUID_PREFIX) - 1, uuidBufLen);
1397         }
1398         else
1399         {
1400             OIC_LOG(ERROR, NET_SSL_TAG, "Could not retrieve UUID from leaf certificate");
1401             return -1;
1402         }
1403
1404         bool isMatched = false;
1405         UuidInfo_t* node = NULL;
1406         UuidInfo_t* tmpNode = NULL;
1407         LL_FOREACH(ctx.list, node)
1408         {
1409             isMatched = isMatched || (0 == memcmp(node->uuid, uuid, UUID_STRING_SIZE));
1410             isMatched = isMatched || (0 == memcmp(node->uuid, UUID_WILDCARD, UUID_STRING_SIZE));
1411         }
1412         LL_FOREACH_SAFE(ctx.list, node, tmpNode)
1413         {
1414             free(node);
1415         }
1416         ctx.list = NULL;
1417         return isMatched ? 0 : -1;
1418     }
1419     return 0;
1420 }
1421
1422 /**
1423  * Creates session for endpoint.
1424  *
1425  * @param[in]  endpoint    remote address
1426  * @param[in]  config    mbedTLS configuration info
1427  *
1428  * @return  TLS endpoint or NULL
1429  */
1430 static SslEndPoint_t * NewSslEndPoint(const CAEndpoint_t * endpoint, mbedtls_ssl_config * config)
1431 {
1432     SslEndPoint_t * tep = NULL;
1433     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1434     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG, "endpoint", NULL);
1435     VERIFY_NON_NULL_RET(config, NET_SSL_TAG, "config", NULL);
1436     VERIFY_NON_NULL_RET(g_caSslContext, NET_SSL_TAG, "SSL Context is NULL", NULL);
1437
1438     tep = (SslEndPoint_t *) OICCalloc(1, sizeof (SslEndPoint_t));
1439     if (NULL == tep)
1440     {
1441         OIC_LOG(ERROR, NET_SSL_TAG, "Malloc failed!");
1442         return NULL;
1443     }
1444
1445     tep->sep.endpoint = *endpoint;
1446     tep->sep.endpoint.flags = (CATransportFlags_t)(tep->sep.endpoint.flags | CA_SECURE);
1447
1448     mbedtls_ssl_conf_verify(config, g_getIdentityCallback ? verifyIdentity : NULL, NULL);
1449
1450     if(0 != mbedtls_ssl_setup(&tep->ssl, config))
1451     {
1452         OIC_LOG(ERROR, NET_SSL_TAG, "Setup failed");
1453         OICFree(tep);
1454         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1455         return NULL;
1456     }
1457
1458     mbedtls_ssl_set_bio(&tep->ssl, tep, SendCallBack, RecvCallBack, NULL);
1459     if (MBEDTLS_SSL_TRANSPORT_DATAGRAM == config->transport)
1460     {
1461         mbedtls_ssl_set_timer_cb(&tep->ssl, &tep->timer,
1462                                   mbedtls_timing_set_delay, mbedtls_timing_get_delay);
1463         if (MBEDTLS_SSL_IS_SERVER == config->endpoint)
1464         {
1465             if (0 != mbedtls_ssl_set_client_transport_id(&tep->ssl,
1466                                     (const unsigned char *) endpoint->addr, sizeof(endpoint->addr)))
1467             {
1468                 OIC_LOG(ERROR, NET_SSL_TAG, "Transport id setup failed!");
1469                 mbedtls_ssl_free(&tep->ssl);
1470                 OICFree(tep);
1471                 OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1472                 return NULL;
1473             }
1474         }
1475     }
1476     tep->cacheList = u_arraylist_create();
1477     if (NULL == tep->cacheList)
1478     {
1479         OIC_LOG(ERROR, NET_SSL_TAG, "cacheList initialization failed!");
1480         mbedtls_ssl_free(&tep->ssl);
1481         OICFree(tep);
1482         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1483         return NULL;
1484     }
1485     OIC_LOG_V(DEBUG, NET_SSL_TAG, "New [%s role] endpoint added [%s:%d]",
1486             (MBEDTLS_SSL_IS_SERVER==config->endpoint ? "server" : "client"),
1487             endpoint->addr, endpoint->port);
1488     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1489     return tep;
1490 }
1491 /**
1492  * Initializes PSK identity.
1493  *
1494  * @param[out]  config    client/server config to be updated
1495  *
1496  * @return  0 on success or -1 on error
1497  */
1498 static int InitPskIdentity(mbedtls_ssl_config * config)
1499 {
1500     uint8_t idBuf[UUID_LENGTH] = {0};
1501     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1502     VERIFY_NON_NULL_RET(config, NET_SSL_TAG, "Param config is NULL" , -1);
1503
1504     if (0 > g_getCredentialsCallback(CA_DTLS_PSK_IDENTITY, NULL, 0, idBuf, UUID_LENGTH))
1505     {
1506         OIC_LOG(ERROR, NET_SSL_TAG, "Identity not found");
1507         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1508         return -1;
1509     }
1510     if (0 != mbedtls_ssl_conf_psk(config, idBuf, 0, idBuf, UUID_LENGTH))
1511     {
1512         OIC_LOG(ERROR, NET_SSL_TAG, "Identity initialization failed!");
1513         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1514         return -1;
1515     }
1516     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1517     return 0;
1518 }
1519
1520 /**
1521  * Select cipher suites for use with (D)TLS based on the credentials available.
1522  *
1523  * @param[in]  config     the (D)TLS configuration object
1524  * @param[in]  adapter    the associated transport adapter
1525  * @param[in]  deviceId   the device ID of the peer we will connect to
1526  *
1527  * @return  true on success or false on error
1528  */
1529 static bool SetupCipher(mbedtls_ssl_config * config, CATransportAdapter_t adapter,
1530                         const char* deviceId)
1531 {
1532     int index = 0;
1533     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1534
1535     VERIFY_NON_NULL_RET(config, NET_SSL_TAG, "Invailid param", false);
1536     VERIFY_NON_NULL_RET(g_caSslContext, NET_SSL_TAG, "SSL Context is NULL", false);
1537     VERIFY_NON_NULL_RET(g_getCredentialTypesCallback, NET_SSL_TAG, "Param callback is null", false);
1538
1539     //Resetting cipherFlag
1540     g_caSslContext->cipherFlag[0] = false;
1541     g_caSslContext->cipherFlag[1] = false;
1542
1543     if (NULL == g_getCredentialTypesCallback)
1544     {
1545         OIC_LOG(ERROR, NET_SSL_TAG, "Param callback is null");
1546         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1547         return false;
1548     }
1549
1550     g_getCredentialTypesCallback(g_caSslContext->cipherFlag, deviceId);
1551
1552     // Retrieve the PSK credential from SRM or use PIN based generation
1553     if ((SSL_ECDHE_PSK_WITH_AES_128_CBC_SHA256 == g_caSslContext->cipher ||
1554          true == g_caSslContext->cipherFlag[0]) && 0 != InitPskIdentity(config))
1555     {
1556         OIC_LOG(ERROR, NET_SSL_TAG, "PSK identity initialization failed!");
1557         /* Don't return error, the connection may work with another cred type */
1558     }
1559
1560     // Retrieve the Cert credential from SRM
1561     if (true == g_caSslContext->cipherFlag[1])
1562     {
1563         int ret = InitPKIX(adapter);
1564         if (0 != ret)
1565         {
1566             OIC_LOG(ERROR, NET_SSL_TAG, "Failed to init X.509");
1567             /* Don't return error, the connection may work with another cred type */
1568         }
1569     }
1570
1571     memset(g_cipherSuitesList, 0, sizeof(g_cipherSuitesList));
1572
1573     // Add the preferred ciphersuite first
1574     if (SSL_CIPHER_MAX != g_caSslContext->cipher)
1575     {
1576         g_cipherSuitesList[index] = tlsCipher[g_caSslContext->cipher][0];
1577         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Preferred ciphersuite added");
1578         index++;
1579     }
1580
1581     // Add PSK ciphersuite
1582     if (true == g_caSslContext->cipherFlag[0] &&
1583                 MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 != tlsCipher[g_caSslContext->cipher][0])
1584     {
1585        g_cipherSuitesList[index] = MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256;
1586        OIC_LOG(DEBUG, NET_SSL_TAG, "PSK ciphersuite added");
1587        index++;
1588     }
1589
1590     // Add all certificate ciphersuites
1591     if (true == g_caSslContext->cipherFlag[1])
1592     {
1593         for (unsigned int i = 0; i < SSL_CIPHER_MAX - 1; i++)
1594         {
1595             if ((MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 != tlsCipher[i][0]) &&
1596                     (i != (unsigned int)g_caSslContext->cipher))
1597             {
1598                 g_cipherSuitesList[index] = tlsCipher[i][0];
1599                 index ++;
1600             }
1601         }
1602     }
1603
1604     OIC_LOG(DEBUG, NET_SSL_TAG, "Supported ciphersuites:");
1605     for (int i = 0; i < index; i++)
1606     {
1607         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Ciphersuite %04x", g_cipherSuitesList[i]);
1608     }
1609
1610     mbedtls_ssl_conf_ciphersuites(config, g_cipherSuitesList);
1611
1612     if (0 == index)
1613     {
1614         OIC_LOG_V(ERROR, NET_SSL_TAG, "No ciphersuites configured, secure connections will fail");
1615         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1616         return false;
1617     }
1618
1619     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1620     return true;
1621 }
1622 /**
1623  * Initiate TLS handshake with endpoint.
1624  *
1625  * @param[in]  endpoint    remote address
1626  *
1627  * @return  TLS endpoint or NULL
1628  */
1629 static SslEndPoint_t * InitiateTlsHandshake(const CAEndpoint_t *endpoint)
1630 {
1631     int ret = 0;
1632     SslEndPoint_t * tep = NULL;
1633
1634     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1635     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG, "Param endpoint is NULL" , NULL);
1636     VERIFY_NON_NULL_RET(g_caSslContext, NET_SSL_TAG, "SSL Context is NULL", NULL);
1637
1638     mbedtls_ssl_config * config = (endpoint->adapter == CA_ADAPTER_IP ||
1639                                    endpoint->adapter == CA_ADAPTER_GATT_BTLE ?
1640                                    &g_caSslContext->clientDtlsConf : &g_caSslContext->clientTlsConf);
1641     tep = NewSslEndPoint(endpoint, config);
1642     if (NULL == tep)
1643     {
1644         OIC_LOG(ERROR, NET_SSL_TAG, "Malloc failed!");
1645         return NULL;
1646     }
1647
1648     //Load allowed SVR suites from SVR DB
1649     if(!SetupCipher(config, endpoint->adapter, endpoint->remoteId))
1650     {
1651         OIC_LOG(ERROR, NET_SSL_TAG, "Failed to set up cipher");
1652         DeleteSslEndPoint(tep);
1653         return NULL;
1654     }
1655
1656     oc_mutex_lock(g_sslContextMutex);
1657     ret = u_arraylist_add(g_caSslContext->peerList, (void *) tep);
1658     if (!ret)
1659     {
1660         oc_mutex_unlock(g_sslContextMutex);
1661         OIC_LOG(ERROR, NET_SSL_TAG, "u_arraylist_add failed!");
1662         DeleteSslEndPoint(tep);
1663         return NULL;
1664     }
1665
1666     while (MBEDTLS_SSL_HANDSHAKE_OVER > tep->ssl.state)
1667     {
1668         ret = mbedtls_ssl_handshake_step(&tep->ssl);
1669         if (MBEDTLS_ERR_SSL_CONN_EOF == ret)
1670         {
1671             break;
1672         }
1673         else if (-1 == ret)
1674         {
1675             OIC_LOG(ERROR, NET_SSL_TAG, "Handshake failed due to socket error");
1676             RemovePeerFromList(&tep->sep.endpoint);
1677             oc_mutex_unlock(g_sslContextMutex);
1678             return NULL;
1679         }
1680         if (!checkSslOperation(tep,
1681                                ret,
1682                                "Handshake error",
1683                                MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE))
1684         {
1685             oc_mutex_unlock(g_sslContextMutex);
1686             OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1687             DeleteSslEndPoint(tep);
1688             return NULL;
1689         }
1690     }
1691
1692     oc_mutex_unlock(g_sslContextMutex);
1693     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1694     return tep;
1695 }
1696 #ifdef __WITH_DTLS__
1697 /**
1698  * Stops DTLS retransmission.
1699  */
1700 static void StopRetransmit(void)
1701 {
1702     if (g_caSslContext)
1703     {
1704         unregisterTimer(g_caSslContext->timerId);
1705         g_caSslContext->timerId= -1;
1706     }
1707 }
1708 #endif
1709 void CAdeinitSslAdapter(void)
1710 {
1711     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1712
1713     VERIFY_NON_NULL_VOID(g_caSslContext, NET_SSL_TAG, "context is NULL");
1714     VERIFY_NON_NULL_VOID(g_sslContextMutex, NET_SSL_TAG, "context mutex is NULL");
1715
1716     //Lock tlsContext mutex
1717     oc_mutex_lock(g_sslContextMutex);
1718
1719     // Clear all lists
1720     DeletePeerList();
1721
1722     // De-initialize mbedTLS
1723     mbedtls_x509_crt_free(&g_caSslContext->crt);
1724     mbedtls_pk_free(&g_caSslContext->pkey);
1725 #ifdef __WITH_TLS__
1726     mbedtls_ssl_config_free(&g_caSslContext->clientTlsConf);
1727     mbedtls_ssl_config_free(&g_caSslContext->serverTlsConf);
1728 #endif // __WITH_TLS__
1729 #ifdef __WITH_DTLS__
1730     mbedtls_ssl_config_free(&g_caSslContext->clientDtlsConf);
1731     mbedtls_ssl_config_free(&g_caSslContext->serverDtlsConf);
1732     mbedtls_ssl_cookie_free(&g_caSslContext->cookieCtx);
1733 #endif // __WITH_DTLS__
1734     mbedtls_ctr_drbg_free(&g_caSslContext->rnd);
1735     mbedtls_entropy_free(&g_caSslContext->entropy);
1736 #ifdef __WITH_DTLS__
1737     StopRetransmit();
1738 #endif
1739     // De-initialize tls Context
1740     OICFree(g_caSslContext);
1741     g_caSslContext = NULL;
1742
1743     // Unlock tlsContext mutex and de-initialize it
1744     oc_mutex_unlock(g_sslContextMutex);
1745     oc_mutex_free(g_sslContextMutex);
1746     g_sslContextMutex = NULL;
1747
1748     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s ", __func__);
1749 }
1750
1751 static int InitConfig(mbedtls_ssl_config * conf, int transport, int mode)
1752 {
1753     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1754     VERIFY_NON_NULL_RET(conf, NET_SSL_TAG, "Param conf is NULL" , -1);
1755     VERIFY_NON_NULL_RET(g_caSslContext, NET_SSL_TAG, "SSL Context is NULL", -1);
1756     mbedtls_ssl_config_init(conf);
1757     if (mbedtls_ssl_config_defaults(conf, mode, transport, MBEDTLS_SSL_PRESET_DEFAULT) != 0)
1758     {
1759         OIC_LOG(ERROR, NET_SSL_TAG, "Config initialization failed!");
1760         return -1;
1761     }
1762
1763     /*
1764      * Configure mbedTLS runtime options. Many options are configured at build
1765      * time, see extlibs/mbedtls/config-iotivity.h
1766      */
1767     mbedtls_ssl_conf_psk_cb(conf, GetPskCredentialsCallback, NULL);
1768     mbedtls_ssl_conf_rng(conf, mbedtls_ctr_drbg_random, &g_caSslContext->rnd);
1769     mbedtls_ssl_conf_curves(conf, curve[ADAPTER_CURVE_SECP256R1]);
1770     mbedtls_ssl_conf_authmode(conf, MBEDTLS_SSL_VERIFY_REQUIRED);
1771
1772 #ifdef __WITH_DTLS__
1773     if (MBEDTLS_SSL_TRANSPORT_DATAGRAM == transport &&
1774             MBEDTLS_SSL_IS_SERVER == mode)
1775     {
1776         mbedtls_ssl_conf_dtls_cookies(conf, mbedtls_ssl_cookie_write, mbedtls_ssl_cookie_check,
1777                                       &g_caSslContext->cookieCtx);
1778     }
1779 #endif // __WITH_DTLS__
1780
1781     /* Set TLS 1.2 as the minimum allowed version. */
1782     mbedtls_ssl_conf_min_version(conf, MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3);
1783
1784 #if !defined(NDEBUG) || defined(TB_LOG)
1785     mbedtls_ssl_conf_dbg(conf, DebugSsl, NULL);
1786 #if defined(MBEDTLS_DEBUG_C)
1787     mbedtls_debug_set_threshold(MBED_TLS_DEBUG_LEVEL);
1788 #endif
1789 #endif
1790     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1791     return 0;
1792 }
1793 #ifdef __WITH_DTLS__
1794 /**
1795  * Starts DTLS retransmission.
1796  */
1797 static void StartRetransmit(void *ctx)
1798 {
1799     size_t listIndex = 0;
1800     size_t listLength = 0;
1801     SslEndPoint_t *tep = NULL;
1802     OC_UNUSED(ctx);
1803
1804     oc_mutex_lock(g_sslContextMutex);
1805     if (NULL == g_caSslContext)
1806     {
1807         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL. Stop retransmission");
1808         oc_mutex_unlock(g_sslContextMutex);
1809         return;
1810     }
1811
1812     if (g_caSslContext->timerId != -1)
1813     {
1814         //clear previous timer
1815         unregisterTimer(g_caSslContext->timerId);
1816
1817         listLength = u_arraylist_length(g_caSslContext->peerList);
1818         for (listIndex = 0; listIndex < listLength; listIndex++)
1819         {
1820             tep = (SslEndPoint_t *) u_arraylist_get(g_caSslContext->peerList, listIndex);
1821             if (NULL == tep
1822                 || (tep->ssl.conf && MBEDTLS_SSL_TRANSPORT_STREAM == tep->ssl.conf->transport)
1823                 || MBEDTLS_SSL_HANDSHAKE_OVER == tep->ssl.state)
1824             {
1825                 continue;
1826             }
1827             int ret = mbedtls_ssl_handshake_step(&tep->ssl);
1828
1829             if (MBEDTLS_ERR_SSL_CONN_EOF != ret)
1830             {
1831                 //start new timer
1832                 registerTimer(RETRANSMISSION_TIME, &g_caSslContext->timerId, StartRetransmit, NULL);
1833                 //unlock & return
1834                 if (!checkSslOperation(tep,
1835                                        ret,
1836                                        "Retransmission",
1837                                        MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE))
1838                 {
1839                     oc_mutex_unlock(g_sslContextMutex);
1840                     return;
1841                 }
1842             }
1843         }
1844     }
1845     //start new timer
1846     registerTimer(RETRANSMISSION_TIME, &g_caSslContext->timerId, StartRetransmit, NULL);
1847     oc_mutex_unlock(g_sslContextMutex);
1848 }
1849 #endif
1850
1851 CAResult_t CAinitSslAdapter(void)
1852 {
1853     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
1854     // Initialize mutex for tlsContext
1855     if (NULL == g_sslContextMutex)
1856     {
1857         g_sslContextMutex = oc_mutex_new_recursive();
1858         VERIFY_NON_NULL_RET(g_sslContextMutex, NET_SSL_TAG, "oc_mutex_new_recursive failed",
1859             CA_MEMORY_ALLOC_FAILED);
1860     }
1861     else
1862     {
1863         OIC_LOG(INFO, NET_SSL_TAG, "Done already!");
1864         return CA_STATUS_OK;
1865     }
1866
1867     // Lock tlsContext mutex and create tlsContext
1868     oc_mutex_lock(g_sslContextMutex);
1869     g_caSslContext = (SslContext_t *)OICCalloc(1, sizeof(SslContext_t));
1870
1871     if (NULL == g_caSslContext)
1872     {
1873         OIC_LOG(ERROR, NET_SSL_TAG, "Context malloc failed");
1874         oc_mutex_unlock(g_sslContextMutex);
1875         oc_mutex_free(g_sslContextMutex);
1876         g_sslContextMutex = NULL;
1877         return CA_MEMORY_ALLOC_FAILED;
1878     }
1879
1880     // Create peer list
1881     g_caSslContext->peerList = u_arraylist_create();
1882
1883     if(NULL == g_caSslContext->peerList)
1884     {
1885         OIC_LOG(ERROR, NET_SSL_TAG, "peerList initialization failed!");
1886         OICFree(g_caSslContext);
1887         g_caSslContext = NULL;
1888         oc_mutex_unlock(g_sslContextMutex);
1889         oc_mutex_free(g_sslContextMutex);
1890         g_sslContextMutex = NULL;
1891         return CA_STATUS_FAILED;
1892     }
1893
1894     /* Initialize TLS library
1895      */
1896 #if !defined(NDEBUG) || defined(TB_LOG)
1897 #ifdef MBEDTLS_VERSION_C
1898     char version[MBED_TLS_VERSION_LEN];
1899     mbedtls_version_get_string(version);
1900     OIC_LOG_V(INFO, NET_SSL_TAG, "mbed TLS version: %s", version);
1901 #else
1902     OIC_LOG_V(INFO, NET_SSL_TAG, "mbed TLS version: %s", MBEDTLS_VERSION_STRING);
1903 #endif
1904 #endif
1905
1906     /* Entropy settings
1907      */
1908     mbedtls_entropy_init(&g_caSslContext->entropy);
1909     mbedtls_ctr_drbg_init(&g_caSslContext->rnd);
1910
1911     if(0 != mbedtls_ctr_drbg_seed(&g_caSslContext->rnd, mbedtls_entropy_func,
1912                                   &g_caSslContext->entropy,
1913                                   (const unsigned char*) PERSONALIZATION_STRING, sizeof(PERSONALIZATION_STRING)))
1914     {
1915         OIC_LOG(ERROR, NET_SSL_TAG, "Seed initialization failed!");
1916         oc_mutex_unlock(g_sslContextMutex);
1917         CAdeinitSslAdapter();
1918         return CA_STATUS_FAILED;
1919     }
1920     mbedtls_ctr_drbg_set_prediction_resistance(&g_caSslContext->rnd, MBEDTLS_CTR_DRBG_PR_ON);
1921
1922 #ifdef __WITH_TLS__
1923     if (0 != InitConfig(&g_caSslContext->clientTlsConf,
1924                         MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_IS_CLIENT))
1925     {
1926         OIC_LOG(ERROR, NET_SSL_TAG, "Client config initialization failed!");
1927         oc_mutex_unlock(g_sslContextMutex);
1928         CAdeinitSslAdapter();
1929         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1930         return CA_STATUS_FAILED;
1931     }
1932
1933     if (0 != InitConfig(&g_caSslContext->serverTlsConf,
1934                         MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_IS_SERVER))
1935     {
1936         OIC_LOG(ERROR, NET_SSL_TAG, "Server config initialization failed!");
1937         oc_mutex_unlock(g_sslContextMutex);
1938         CAdeinitSslAdapter();
1939         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1940         return CA_STATUS_FAILED;
1941     }
1942 #endif // __WITH_TLS__
1943 #ifdef __WITH_DTLS__
1944     mbedtls_ssl_cookie_init(&g_caSslContext->cookieCtx);
1945     if (0 != mbedtls_ssl_cookie_setup(&g_caSslContext->cookieCtx, mbedtls_ctr_drbg_random,
1946                                       &g_caSslContext->rnd))
1947     {
1948         OIC_LOG(ERROR, NET_SSL_TAG, "Cookie setup failed!");
1949         oc_mutex_unlock(g_sslContextMutex);
1950         CAdeinitSslAdapter();
1951         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1952         return CA_STATUS_FAILED;
1953     }
1954
1955     if (0 != InitConfig(&g_caSslContext->clientDtlsConf,
1956                         MBEDTLS_SSL_TRANSPORT_DATAGRAM, MBEDTLS_SSL_IS_CLIENT))
1957     {
1958         OIC_LOG(ERROR, NET_SSL_TAG, "Client config initialization failed!");
1959         oc_mutex_unlock(g_sslContextMutex);
1960         CAdeinitSslAdapter();
1961         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1962         return CA_STATUS_FAILED;
1963     }
1964
1965     if (0 != InitConfig(&g_caSslContext->serverDtlsConf,
1966                         MBEDTLS_SSL_TRANSPORT_DATAGRAM, MBEDTLS_SSL_IS_SERVER))
1967     {
1968         OIC_LOG(ERROR, NET_SSL_TAG, "Server config initialization failed!");
1969         oc_mutex_unlock(g_sslContextMutex);
1970         CAdeinitSslAdapter();
1971         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1972         return CA_STATUS_FAILED;
1973     }
1974 #endif // __WITH_DTLS__
1975
1976     // set default cipher
1977     g_caSslContext->cipher = SSL_CIPHER_MAX;
1978
1979     // init X.509
1980     mbedtls_x509_crt_init(&g_caSslContext->ca);
1981     mbedtls_x509_crt_init(&g_caSslContext->crt);
1982     mbedtls_pk_init(&g_caSslContext->pkey);
1983     mbedtls_x509_crl_init(&g_caSslContext->crl);
1984
1985 #ifdef __WITH_DTLS__
1986     g_caSslContext->timerId = -1;
1987 #endif
1988
1989    oc_mutex_unlock(g_sslContextMutex);
1990 #ifdef __WITH_DTLS__
1991     StartRetransmit(NULL);
1992 #endif
1993
1994     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
1995     return CA_STATUS_OK;
1996 }
1997
1998 SslCacheMessage_t *NewCacheMessage(uint8_t * data, size_t dataLen)
1999 {
2000     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
2001     VERIFY_NON_NULL_RET(data, NET_SSL_TAG, "Param data is NULL" , NULL);
2002     if (0 == dataLen)
2003     {
2004         OIC_LOG(ERROR, NET_SSL_TAG, "dataLen is equal to zero");
2005         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2006         return NULL;
2007     }
2008     SslCacheMessage_t * message = (SslCacheMessage_t *) OICCalloc(1, sizeof(SslCacheMessage_t));
2009     if (NULL == message)
2010     {
2011         OIC_LOG(ERROR, NET_SSL_TAG, "calloc failed!");
2012         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2013         return NULL;
2014     }
2015
2016     message->data = (uint8_t *)OICCalloc(dataLen, sizeof(uint8_t));
2017     if (NULL == message->data)
2018     {
2019         OIC_LOG(ERROR, NET_SSL_TAG, "calloc failed!");
2020         OICFree(message);
2021         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2022         return NULL;
2023     }
2024     memcpy(message->data, data, dataLen);
2025     message->len = dataLen;
2026     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2027     return message;
2028 }
2029
2030 /* Send data via TLS connection.
2031  */
2032 CAResult_t CAencryptSsl(const CAEndpoint_t *endpoint,
2033                         const void *data, size_t dataLen)
2034 {
2035     int ret = 0;
2036
2037     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s ", __func__);
2038
2039     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG,"Remote address is NULL", CA_STATUS_INVALID_PARAM);
2040     VERIFY_NON_NULL_RET(data, NET_SSL_TAG, "Data is NULL", CA_STATUS_INVALID_PARAM);
2041     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Port %d", endpoint->port);
2042
2043     if (0 == dataLen)
2044     {
2045         OIC_LOG_V(ERROR, NET_SSL_TAG, "dataLen is zero [%" PRIuPTR "]", dataLen);
2046         return CA_STATUS_FAILED;
2047     }
2048
2049     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Data to be encrypted dataLen [%" PRIuPTR "]", dataLen);
2050
2051     oc_mutex_lock(g_sslContextMutex);
2052     if(NULL == g_caSslContext)
2053     {
2054         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
2055         oc_mutex_unlock(g_sslContextMutex);
2056         return CA_STATUS_FAILED;
2057     }
2058
2059     SslEndPoint_t * tep = GetSslPeer(endpoint);
2060     if (NULL == tep)
2061     {
2062         tep = InitiateTlsHandshake(endpoint);
2063     }
2064     if (NULL == tep)
2065     {
2066         OIC_LOG(ERROR, NET_SSL_TAG, "TLS handshake failed");
2067         oc_mutex_unlock(g_sslContextMutex);
2068         return CA_STATUS_FAILED;
2069     }
2070
2071     if (MBEDTLS_SSL_HANDSHAKE_OVER == tep->ssl.state)
2072     {
2073         unsigned char *dataBuf = (unsigned char *)data;
2074         size_t written = 0;
2075
2076         do
2077         {
2078             ret = mbedtls_ssl_write(&tep->ssl, dataBuf, dataLen - written);
2079             if (ret < 0)
2080             {
2081                 if (MBEDTLS_ERR_SSL_WANT_WRITE != ret)
2082                 {
2083                     OIC_LOG_V(ERROR, NET_SSL_TAG, "mbedTLS write failed! returned 0x%x", -ret);
2084                     RemovePeerFromList(&tep->sep.endpoint);
2085                     oc_mutex_unlock(g_sslContextMutex);
2086                     return CA_STATUS_FAILED;
2087                 }
2088                 continue;
2089             }
2090             OIC_LOG_V(DEBUG, NET_SSL_TAG, "mbedTLS write returned with sent bytes[%d]", ret);
2091
2092             dataBuf += ret;
2093             written += ret;
2094         } while (dataLen > written);
2095
2096     }
2097     else
2098     {
2099         SslCacheMessage_t * msg = NewCacheMessage((uint8_t*) data, dataLen);
2100         if (NULL == msg || !u_arraylist_add(tep->cacheList, (void *) msg))
2101         {
2102             OIC_LOG(ERROR, NET_SSL_TAG, "u_arraylist_add failed!");
2103             oc_mutex_unlock(g_sslContextMutex);
2104             return CA_STATUS_FAILED;
2105         }
2106     }
2107
2108     oc_mutex_unlock(g_sslContextMutex);
2109
2110     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2111     return CA_STATUS_OK;
2112 }
2113 /**
2114  * Sends cached messages via TLS connection.
2115  *
2116  * @param[in]  tep    remote address with session info
2117  */
2118 static void SendCacheMessages(SslEndPoint_t * tep, CAResult_t errorCode)
2119 {
2120     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
2121
2122     // The mutex protects the access to tep.
2123     oc_mutex_assert_owner(g_sslContextMutex, true);
2124
2125     VERIFY_NON_NULL_VOID(tep, NET_SSL_TAG, "Param tep is NULL");
2126
2127     CAErrorHandleCallback sendError = NULL;
2128     if (errorCode != CA_STATUS_OK)
2129     {
2130         int adapterIndex = GetAdapterIndex(tep->sep.endpoint.adapter);
2131         if (adapterIndex >= 0)
2132         {
2133             sendError = g_caSslContext->adapterCallbacks[adapterIndex].errorCallback;
2134         }
2135     }
2136
2137     size_t listIndex = 0;
2138     size_t listLength = 0;
2139     listLength = u_arraylist_length(tep->cacheList);
2140     for (listIndex = 0; listIndex < listLength;)
2141     {
2142         int ret = 0;
2143         SslCacheMessage_t * msg = (SslCacheMessage_t *) u_arraylist_get(tep->cacheList, listIndex);
2144         if (NULL != msg && NULL != msg->data && 0 != msg->len)
2145         {
2146             if (CA_STATUS_OK == errorCode)
2147             {
2148                 unsigned char *dataBuf = (unsigned char *)msg->data;
2149                 size_t written = 0;
2150
2151                 do
2152                 {
2153                     ret = mbedtls_ssl_write(&tep->ssl, dataBuf, msg->len - written);
2154                     if (ret < 0)
2155                     {
2156                         if (MBEDTLS_ERR_SSL_WANT_WRITE != ret)
2157                         {
2158                             OIC_LOG_V(ERROR, NET_SSL_TAG, "mbedTLS write failed! returned -0x%x", -ret);
2159                             break;
2160                         }
2161                         continue;
2162                     }
2163                     OIC_LOG_V(DEBUG, NET_SSL_TAG, "mbedTLS write returned with sent bytes[%d]", ret);
2164
2165                     dataBuf += ret;
2166                     written += ret;
2167                 } while (msg->len > written);
2168             }
2169             else if (NULL != sendError)
2170             {
2171                 //send error info via error callback to app layer
2172                 sendError(&tep->sep.endpoint, (uint8_t *)msg->data, msg->len, errorCode);
2173             }
2174
2175             if (u_arraylist_remove(tep->cacheList, listIndex))
2176             {
2177                 DeleteCacheMessage(msg);
2178                 // Reduce list length by 1 as we removed one element.
2179                 listLength--;
2180             }
2181             else
2182             {
2183                 OIC_LOG(ERROR, NET_SSL_TAG, "u_arraylist_remove failed.");
2184                 break;
2185             }
2186         }
2187         else
2188         {
2189             // Move to the next element
2190             ++listIndex;
2191         }
2192     }
2193     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2194 }
2195
2196 void CAsetSslHandshakeCallback(CAHandshakeErrorCallback tlsHandshakeCallback)
2197 {
2198     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s(%p)", __func__, tlsHandshakeCallback);
2199
2200     oc_mutex_lock(g_sslContextMutex);
2201     g_sslCallback = tlsHandshakeCallback;
2202     oc_mutex_unlock(g_sslContextMutex);
2203
2204     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s(%p)", __func__, tlsHandshakeCallback);
2205 }
2206
2207 /* Read data from TLS connection
2208  */
2209 CAResult_t CAdecryptSsl(const CASecureEndpoint_t *sep, uint8_t *data, size_t dataLen)
2210 {
2211     int ret = 0;
2212     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
2213     VERIFY_NON_NULL_RET(sep, NET_SSL_TAG, "endpoint is NULL" , CA_STATUS_INVALID_PARAM);
2214     VERIFY_NON_NULL_RET(data, NET_SSL_TAG, "Param data is NULL" , CA_STATUS_INVALID_PARAM);
2215
2216     oc_mutex_lock(g_sslContextMutex);
2217     if (NULL == g_caSslContext)
2218     {
2219         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
2220         oc_mutex_unlock(g_sslContextMutex);
2221         return CA_STATUS_FAILED;
2222     }
2223
2224     SslEndPoint_t * peer = GetSslPeer(&sep->endpoint);
2225     if (NULL == peer)
2226     {
2227         mbedtls_ssl_config * config = (sep->endpoint.adapter == CA_ADAPTER_IP ||
2228                                    sep->endpoint.adapter == CA_ADAPTER_GATT_BTLE ?
2229                                    &g_caSslContext->serverDtlsConf : &g_caSslContext->serverTlsConf);
2230         peer = NewSslEndPoint(&sep->endpoint, config);
2231         if (NULL == peer)
2232         {
2233             OIC_LOG(ERROR, NET_SSL_TAG, "Malloc failed!");
2234             oc_mutex_unlock(g_sslContextMutex);
2235             return CA_STATUS_FAILED;
2236         }
2237         //Load allowed TLS suites from SVR DB
2238         if(!SetupCipher(config, sep->endpoint.adapter, NULL))
2239         {
2240             OIC_LOG(ERROR, NET_SSL_TAG, "Failed to set up cipher");
2241             DeleteSslEndPoint(peer);
2242             oc_mutex_unlock(g_sslContextMutex);
2243             return CA_STATUS_FAILED;
2244         }
2245
2246         ret = u_arraylist_add(g_caSslContext->peerList, (void *) peer);
2247         if (!ret)
2248         {
2249             OIC_LOG(ERROR, NET_SSL_TAG, "u_arraylist_add failed!");
2250             DeleteSslEndPoint(peer);
2251             oc_mutex_unlock(g_sslContextMutex);
2252             return CA_STATUS_FAILED;
2253         }
2254     }
2255
2256     peer->recBuf.buff = data;
2257     peer->recBuf.len = dataLen;
2258     peer->recBuf.loaded = 0;
2259
2260     while (MBEDTLS_SSL_HANDSHAKE_OVER != peer->ssl.state)
2261     {
2262         ret = mbedtls_ssl_handshake_step(&peer->ssl);
2263         if (MBEDTLS_ERR_SSL_CONN_EOF == ret)
2264         {
2265             break;
2266         }
2267
2268         if (MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED == ret)
2269         {
2270             OIC_LOG(DEBUG, NET_SSL_TAG, "Hello verification requested");
2271             mbedtls_ssl_session_reset(&peer->ssl);
2272             mbedtls_ssl_set_client_transport_id(&peer->ssl,
2273                                                 (const unsigned char *) sep->endpoint.addr,
2274                                                  sizeof(sep->endpoint.addr));
2275             ret = mbedtls_ssl_handshake_step(&peer->ssl);
2276         }
2277         uint32_t flags = mbedtls_ssl_get_verify_result(&peer->ssl);
2278         if (0 != flags)
2279         {
2280             size_t bufSize = 1024;
2281             char *bufMsg = (char*)OICCalloc(1, bufSize);
2282             if (bufMsg)
2283             {
2284                 mbedtls_x509_crt_verify_info(bufMsg, bufSize, "", flags);
2285                 OIC_LOG_V(ERROR, NET_SSL_TAG, "%s: session verification(%X): %s", __func__, flags, bufMsg);
2286                 OICFree(bufMsg);
2287             }
2288             else
2289             {
2290                 OIC_LOG_V(ERROR, NET_SSL_TAG, "%s: session verification(%X)", __func__, flags);
2291             }
2292
2293             OIC_LOG_BUFFER(ERROR, NET_SSL_TAG, (const uint8_t *) &flags, sizeof(flags));
2294
2295             if (!checkSslOperation(peer,
2296                                    (int)flags,
2297                                    "Cert verification failed",
2298                                    GetAlertCode(flags)))
2299             {
2300                 oc_mutex_unlock(g_sslContextMutex);
2301                 OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2302                 return CA_STATUS_FAILED;
2303             }
2304         }
2305         if (!checkSslOperation(peer,
2306                                ret,
2307                                "Handshake error",
2308                                MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE))
2309         {
2310             oc_mutex_unlock(g_sslContextMutex);
2311             OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2312             return CA_STATUS_FAILED;
2313         }
2314
2315         if (MBEDTLS_SSL_CERTIFICATE_VERIFY == peer->ssl.state)
2316         {
2317             mbedtls_x509_crt *peerCert = peer->ssl.session_negotiate->peer_cert;
2318             if (NULL != peerCert)
2319             {
2320                 ret = ValidateAuthCertChainProfiles(peerCert);
2321                 if (CP_INVALID_CERT_CHAIN == ret)
2322                 {
2323                     oc_mutex_unlock(g_sslContextMutex);
2324                     OIC_LOG(ERROR, NET_SSL_TAG, "Invalid peer cert chain");
2325                     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2326                     return CA_STATUS_FAILED;
2327                 }
2328                 else if (0 != ret)
2329                 {
2330                     oc_mutex_unlock(g_sslContextMutex);
2331                     OIC_LOG_V(ERROR, NET_SSL_TAG, "%d certificate(s) in peer cert chain do not satisfy OCF profile requirements", ret);
2332                     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2333                     return CA_STATUS_FAILED;
2334                 }
2335
2336                 ret = PeerCertExtractCN(peerCert);
2337                 if (CA_STATUS_OK != ret)
2338                 {
2339                     oc_mutex_unlock(g_sslContextMutex);
2340                     OIC_LOG_V(ERROR, NET_SSL_TAG, "ProcessPeerCert failed with %d", ret);
2341                     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2342                     return CA_STATUS_FAILED;
2343                 }
2344             }
2345         }
2346
2347         if (MBEDTLS_SSL_CLIENT_CHANGE_CIPHER_SPEC == peer->ssl.state)
2348         {
2349             memcpy(peer->master, peer->ssl.session_negotiate->master, sizeof(peer->master));
2350             g_caSslContext->selectedCipher = peer->ssl.session_negotiate->ciphersuite;
2351         }
2352         if (MBEDTLS_SSL_CLIENT_KEY_EXCHANGE == peer->ssl.state)
2353         {
2354             memcpy(peer->random, peer->ssl.handshake->randbytes, sizeof(peer->random));
2355         }
2356
2357         if (MBEDTLS_SSL_HANDSHAKE_OVER == peer->ssl.state)
2358         {
2359             CAResult_t result = notifySubscriber(peer, CA_STATUS_OK);
2360
2361             if (MBEDTLS_SSL_IS_CLIENT == peer->ssl.conf->endpoint)
2362             {
2363                 SendCacheMessages(peer, result);
2364             }
2365
2366             int selectedCipher = peer->ssl.session->ciphersuite;
2367             OIC_LOG_V(DEBUG, NET_SSL_TAG, "(D)TLS Session is connected via ciphersuite [0x%x]", selectedCipher);
2368             if (MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 != selectedCipher &&
2369                 MBEDTLS_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA256 != selectedCipher)
2370             {
2371                 const mbedtls_x509_crt * peerCert = mbedtls_ssl_get_peer_cert(&peer->ssl);
2372                 const mbedtls_x509_name * name = NULL;
2373                 uint8_t pubKeyBuf[CA_SECURE_ENDPOINT_PUBLIC_KEY_MAX_LENGTH] = { 0 };
2374                 ret = (NULL == peerCert ? -1 : 0);
2375                 if (!checkSslOperation(peer,
2376                                        ret,
2377                                        "Failed to retrieve cert",
2378                                        MBEDTLS_SSL_ALERT_MSG_NO_CERT))
2379                 {
2380                     oc_mutex_unlock(g_sslContextMutex);
2381                     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2382                     return CA_STATUS_FAILED;
2383                 }
2384
2385                 /* mbedtls_pk_write_pubkey_der takes a non-const mbedtls_pk_context, but inspection
2386                  * shows that every place it's used internally treats it as const, so casting its
2387                  * constness away is safe.
2388                  */
2389                 ret = mbedtls_pk_write_pubkey_der((mbedtls_pk_context *)&peerCert->pk, pubKeyBuf, sizeof(pubKeyBuf));
2390                 if (ret <= 0)
2391                 {
2392                     OIC_LOG_V(ERROR, NET_SSL_TAG, "Failed to copy public key of remote peer: -0x%x", ret);
2393                     oc_mutex_unlock(g_sslContextMutex);
2394                     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2395                     return CA_STATUS_FAILED;
2396                 }
2397                 else if ((size_t)ret > sizeof(peer->sep.publicKey))
2398                 {
2399                     assert(!"publicKey field of CASecureEndpoint_t is too small for the public key!");
2400                     OIC_LOG(ERROR, NET_SSL_TAG, "Public key of remote peer was too large");
2401                     oc_mutex_unlock(g_sslContextMutex);
2402                     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2403                     return CA_STATUS_FAILED;
2404                 }
2405                 /* DER data is written to the end of the buffer, so we have to skip ahead in it. */
2406                 memcpy(peer->sep.publicKey, (pubKeyBuf + sizeof(pubKeyBuf) - ret), ret);
2407                 peer->sep.publicKeyLength = ret;
2408
2409                 /* Find the CN component of the subject name. */
2410                 for (name = &peerCert->subject; NULL != name; name = name->next)
2411                 {
2412                     if (name->oid.p &&
2413                        (name->oid.len <= MBEDTLS_OID_SIZE(MBEDTLS_OID_AT_CN)) &&
2414                        (0 == memcmp(MBEDTLS_OID_AT_CN, name->oid.p, name->oid.len)))
2415                     {
2416                         break;
2417                     }
2418                 }
2419
2420                 if (NULL == name)
2421                 {
2422                     OIC_LOG(WARNING, NET_SSL_TAG, "no CN RDN found in subject name");
2423                 }
2424                 else
2425                 {
2426                     const size_t uuidBufLen = UUID_STRING_SIZE - 1;
2427                     char uuid[UUID_STRING_SIZE] = { 0 };
2428                     const unsigned char * uuidPos = NULL;
2429                     const unsigned char * userIdPos = NULL;
2430                     uint8_t uuid_found = 0;
2431
2432                     uuidPos = (const unsigned char*)memmem(name->val.p, name->val.len,
2433                                                            UUID_PREFIX, sizeof(UUID_PREFIX) - 1);
2434
2435                     /* If UUID_PREFIX is present, ensure there's enough data for the prefix plus an entire
2436                      * UUID, to make sure we don't read past the end of the buffer.
2437                      */
2438                     if ((NULL != uuidPos) &&
2439                         (name->val.len >= ((uuidPos - name->val.p) + (sizeof(UUID_PREFIX) - 1) + uuidBufLen)))
2440                     {
2441                         memcpy(uuid, uuidPos + sizeof(UUID_PREFIX) - 1, uuidBufLen);
2442                         OIC_LOG(INFO, NET_SSL_TAG, "uuid tag found");
2443                         uuid_found = 1;
2444                     }
2445                     else
2446                     {
2447                         OIC_LOG(WARNING, NET_SSL_TAG, "uuid tag not found");
2448                     }
2449
2450                     userIdPos = (const unsigned char*)memmem(name->val.p, name->val.len,
2451                                                              USERID_PREFIX, sizeof(USERID_PREFIX) - 1);
2452
2453                     /* If USERID_PREFIX is present, ensure there's enough data for the prefix plus an entire
2454                      * UUID, to make sure we don't read past the end of the buffer.
2455                      */
2456                     if ((NULL != userIdPos) &&
2457                         (name->val.len >= ((userIdPos - name->val.p) + (sizeof(USERID_PREFIX) - 1) + uuidBufLen)))
2458                     {
2459                         memcpy(uuid, userIdPos + sizeof(USERID_PREFIX) - 1, uuidBufLen);
2460                         OIC_LOG(INFO, NET_SSL_TAG, "userid tag found");
2461                         uuid_found = 1;
2462                     }
2463                     else
2464                     {
2465                         OIC_LOG(WARNING, NET_SSL_TAG, "userid tag not found");
2466                     }
2467
2468                     if (!uuid_found && name->val.len > sizeof(UUID_PREFIX))
2469                     {
2470                         memcpy(uuid, name->val.p, name->val.len);
2471                         uuid_found = 1;
2472                     }
2473                     else if (uuid_found)
2474                     {
2475                         OIC_LOG_V(DEBUG, NET_SSL_TAG, "certificate uuid string: %s", uuid);
2476                         ret = (OCConvertStringToUuid(uuid, peer->sep.identity.id)) ? 0 : -1;
2477                         if (!checkSslOperation(peer,
2478                                                ret,
2479                                                "Failed to convert subject alt name",
2480                                                MBEDTLS_SSL_ALERT_MSG_UNSUPPORTED_CERT))
2481                         {
2482                             oc_mutex_unlock(g_sslContextMutex);
2483                             OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2484                             return CA_STATUS_FAILED;
2485                         }
2486                     }
2487                     else
2488                     {
2489                         OIC_LOG(WARNING, NET_SSL_TAG, "neither uuid nor userid not found");
2490                     }
2491                 }
2492             }
2493             else
2494             {
2495                 /* No public key information for non-certificate-using ciphersuites. */
2496                 memset(&peer->sep.publicKey, 0, sizeof(peer->sep.publicKey));
2497                 peer->sep.publicKeyLength = 0;
2498             }
2499
2500             oc_mutex_unlock(g_sslContextMutex);
2501             OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2502             return CA_STATUS_OK;
2503         }
2504     }
2505
2506     if (MBEDTLS_SSL_HANDSHAKE_OVER == peer->ssl.state)
2507     {
2508         uint8_t decryptBuffer[TLS_MSG_BUF_LEN] = {0};
2509         do
2510         {
2511             ret = mbedtls_ssl_read(&peer->ssl, decryptBuffer, TLS_MSG_BUF_LEN);
2512         } while (MBEDTLS_ERR_SSL_WANT_READ == ret);
2513
2514         if (MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY == ret ||
2515             // TinyDTLS sends fatal close_notify alert
2516             (MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE == ret &&
2517              MBEDTLS_SSL_ALERT_LEVEL_FATAL == peer->ssl.in_msg[0] &&
2518              MBEDTLS_SSL_ALERT_MSG_CLOSE_NOTIFY == peer->ssl.in_msg[1]))
2519         {
2520             OIC_LOG(INFO, NET_SSL_TAG, "Connection was closed gracefully");
2521
2522             if (NULL != g_closeSslConnectionCallback)
2523             {
2524                 g_closeSslConnectionCallback(peer->sep.identity.id, peer->sep.identity.id_length);
2525             }
2526
2527             do
2528             {
2529                 ret = mbedtls_ssl_close_notify(&peer->ssl);
2530             }
2531             while (MBEDTLS_ERR_SSL_WANT_WRITE == ret);
2532
2533             RemovePeerFromList(&peer->sep.endpoint);
2534             oc_mutex_unlock(g_sslContextMutex);
2535             return CA_STATUS_OK;
2536         }
2537
2538         int adapterIndex = GetAdapterIndex(peer->sep.endpoint.adapter);
2539         if (adapterIndex >= 0)
2540         {
2541             if (0 > ret)
2542             {
2543                 OIC_LOG_V(ERROR, NET_SSL_TAG, "mbedtls_ssl_read returned -0x%x", -ret);
2544                 g_caSslContext->adapterCallbacks[adapterIndex].errorCallback(&peer->sep.endpoint, peer->recBuf.buff, peer->recBuf.len, CA_STATUS_FAILED);
2545                 RemovePeerFromList(&peer->sep.endpoint);
2546                 oc_mutex_unlock(g_sslContextMutex);
2547                 return CA_STATUS_FAILED;
2548             }
2549             else if (0 < ret)
2550             {
2551                 g_caSslContext->adapterCallbacks[adapterIndex].recvCallback(&peer->sep, decryptBuffer, ret);
2552             }
2553         }
2554         else
2555         {
2556             OIC_LOG(ERROR, NET_SSL_TAG, "Unsuported adapter");
2557             RemovePeerFromList(&peer->sep.endpoint);
2558             oc_mutex_unlock(g_sslContextMutex);
2559             return CA_STATUS_FAILED;
2560         }
2561     }
2562
2563     oc_mutex_unlock(g_sslContextMutex);
2564     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2565     return CA_STATUS_OK;
2566 }
2567
2568 void CAsetSslAdapterCallbacks(CAPacketReceivedCallback recvCallback,
2569                               CAPacketSendCallback sendCallback,
2570                               CAErrorHandleCallback errorCallback,
2571                               CATransportAdapter_t type)
2572 {
2573     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
2574     VERIFY_NON_NULL_VOID(sendCallback, NET_SSL_TAG, "sendCallback is NULL");
2575     VERIFY_NON_NULL_VOID(recvCallback, NET_SSL_TAG, "recvCallback is NULL");
2576     VERIFY_NON_NULL_VOID(errorCallback, NET_SSL_TAG, "errorCallback is NULL");
2577
2578     oc_mutex_lock(g_sslContextMutex);
2579     if (NULL == g_caSslContext)
2580     {
2581         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
2582         oc_mutex_unlock(g_sslContextMutex);
2583         return;
2584     }
2585
2586     int index = GetAdapterIndex(type);
2587     if (index >= 0)
2588     {
2589         g_caSslContext->adapterCallbacks[index].recvCallback  = recvCallback;
2590         g_caSslContext->adapterCallbacks[index].sendCallback  = sendCallback;
2591         g_caSslContext->adapterCallbacks[index].errorCallback = errorCallback;
2592     }
2593
2594     oc_mutex_unlock(g_sslContextMutex);
2595     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2596 }
2597 /**
2598  * Gets index of the TLS ciphersuite in the SslCipher_t enum.
2599  *
2600  * @param[in]  cipher    TLS chiphersuite code
2601  *
2602  * @return   corresponding enum
2603  */
2604
2605 static SslCipher_t GetCipherIndex(const uint32_t cipher)
2606 {
2607     switch(cipher)
2608     {
2609         case MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA256:
2610         {
2611             return SSL_RSA_WITH_AES_256_CBC_SHA256;
2612         }
2613         case MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256:
2614         {
2615             return SSL_RSA_WITH_AES_128_GCM_SHA256;
2616         }
2617         case MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256:
2618         {
2619             return SSL_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256;
2620         }
2621         case MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8:
2622         {
2623             return SSL_ECDHE_ECDSA_WITH_AES_128_CCM_8;
2624         }
2625         case MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM:
2626         {
2627             return SSL_ECDHE_ECDSA_WITH_AES_128_CCM;
2628         }
2629         case MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256:
2630         {
2631             return SSL_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256;
2632         }
2633         case MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384:
2634         {
2635             return SSL_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384;
2636         }
2637         case MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384:
2638         {
2639             return SSL_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384;
2640         }
2641         case MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256:
2642         {
2643             return SSL_ECDHE_PSK_WITH_AES_128_CBC_SHA256;
2644         }
2645         case MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256:
2646         {
2647             return SSL_ECDHE_RSA_WITH_AES_128_CBC_SHA256;
2648         }
2649         case MBEDTLS_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA256:
2650         {
2651             return SSL_ECDH_ANON_WITH_AES_128_CBC_SHA256;
2652         }
2653         default:
2654         {
2655             return SSL_CIPHER_MAX;
2656         }
2657     }
2658 }
2659
2660 CAResult_t CAsetTlsCipherSuite(const uint32_t cipher)
2661 {
2662     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
2663     oc_mutex_lock(g_sslContextMutex);
2664
2665     if (NULL == g_caSslContext)
2666     {
2667         OIC_LOG(ERROR, NET_SSL_TAG, "SSL context is not initialized.");
2668         oc_mutex_unlock(g_sslContextMutex);
2669         return CA_STATUS_NOT_INITIALIZED;
2670     }
2671
2672     SslCipher_t index = GetCipherIndex(cipher);
2673     if (SSL_CIPHER_MAX == index)
2674     {
2675         OIC_LOG(WARNING, NET_SSL_TAG, "Unknown cipher");
2676     }
2677     else
2678     {
2679 #ifdef __WITH_TLS__
2680         CONF_SSL(&g_caSslContext->clientTlsConf, &g_caSslContext->serverTlsConf,
2681         mbedtls_ssl_conf_ciphersuites, tlsCipher[index]);
2682 #endif
2683 #ifdef __WITH_DTLS__
2684         CONF_SSL(&g_caSslContext->clientDtlsConf, &g_caSslContext->serverDtlsConf,
2685         mbedtls_ssl_conf_ciphersuites, tlsCipher[index]);
2686 #endif
2687         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Selected cipher: 0x%x", cipher);
2688     }
2689     g_caSslContext->cipher = index;
2690
2691     oc_mutex_unlock(g_sslContextMutex);
2692     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2693     return CA_STATUS_OK;
2694 }
2695
2696 CAResult_t CAinitiateSslHandshake(const CAEndpoint_t *endpoint)
2697 {
2698     CAResult_t res = CA_STATUS_OK;
2699     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
2700     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG, "Param endpoint is NULL" , CA_STATUS_INVALID_PARAM);
2701     oc_mutex_lock(g_sslContextMutex);
2702
2703     if (NULL != GetSslPeer(endpoint))
2704     {
2705         OIC_LOG(WARNING, NET_SSL_TAG, "Secure session exists and will be closed");
2706         if (CA_STATUS_OK != CAcloseSslConnection(endpoint))
2707         {
2708             OIC_LOG(WARNING, NET_SSL_TAG, "Failed to close secure session");
2709         }
2710     }
2711
2712     if (NULL == InitiateTlsHandshake(endpoint))
2713     {
2714         OIC_LOG(ERROR, NET_SSL_TAG, "TLS handshake failed");
2715         res = CA_STATUS_FAILED;
2716     }
2717
2718     oc_mutex_unlock(g_sslContextMutex);
2719     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2720     return res;
2721 }
2722 /**
2723  * Expands the secret into blocks of data according
2724  * to the algorithm specified in section 5 of RFC 4346
2725  *
2726  * This function writes upto @p bufLen bytes into the given output buffer @p buf
2727  *
2728  * @param  key    secret key.
2729  * @param  keyLen    secret key length.
2730  * @param  label    A PRF label.
2731  * @param  labelLen     Actual length of @p label.
2732  * @param  random1    Random seed.
2733  * @param  random1Len     Actual length of @p random1 (may be zero).
2734  * @param  random2     Random seed.
2735  * @param  random2Len    Actual length of @p random2 (may be zero).
2736  * @param  buf    Output buffer for generated random data.
2737  * @param  bufLen    Maximum size of @p buf. Must not be larger than INT_MAX.
2738  *
2739  * @return The actual number of bytes written to @p buf or @c -1 on error.
2740  */
2741
2742 static int pHash (const unsigned char *key, size_t keyLen,
2743      const unsigned char *label, size_t labelLen,
2744      const unsigned char *random1, size_t random1Len,
2745      const unsigned char *random2, size_t random2Len,
2746      unsigned char *buf, size_t bufLen)
2747 {
2748     unsigned char A[MBEDTLS_MD_MAX_SIZE] = {0};
2749     unsigned char tmp[MBEDTLS_MD_MAX_SIZE] = {0};
2750     size_t dLen;   /* digest length */
2751     size_t len = 0;   /* result length */
2752     const mbedtls_md_type_t hashAlg = MBEDTLS_MD_SHA256;
2753
2754     VERIFY_TRUE_RET(bufLen <= INT_MAX, NET_SSL_TAG, "buffer too large", -1);
2755     VERIFY_NON_NULL_RET(key, NET_SSL_TAG, "key is NULL", -1);
2756     VERIFY_NON_NULL_RET(label, NET_SSL_TAG, "label is NULL", -1);
2757     VERIFY_NON_NULL_RET(random1, NET_SSL_TAG, "random1 is NULL", -1);
2758     VERIFY_NON_NULL_RET(random2, NET_SSL_TAG, "random2 is NULL", -1);
2759     VERIFY_NON_NULL_RET(buf, NET_SSL_TAG, "buf is NULL", -1);
2760
2761     mbedtls_md_context_t hmacA;
2762     mbedtls_md_context_t hmacP;
2763
2764     mbedtls_md_init(&hmacA);
2765     mbedtls_md_init(&hmacP);
2766
2767     CHECK_MBEDTLS_RET(mbedtls_md_setup, &hmacA, mbedtls_md_info_from_type(hashAlg), 1);
2768     CHECK_MBEDTLS_RET(mbedtls_md_setup, &hmacP, mbedtls_md_info_from_type(hashAlg), 1);
2769
2770     CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacA, key, keyLen );
2771     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacA, label, labelLen);
2772     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacA, random1, random1Len);
2773     CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacA, random2, random2Len);
2774     CHECK_MBEDTLS_RET(mbedtls_md_hmac_finish, &hmacA, A);
2775
2776     dLen = mbedtls_md_get_size(mbedtls_md_info_from_type(hashAlg));
2777
2778     CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacP, key, keyLen);
2779
2780     while (len + dLen <= bufLen)
2781     {
2782         CHECK_MBEDTLS_RET(mbedtls_md_hmac_reset, &hmacP);
2783         CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacP, key, keyLen);
2784         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, A, dLen);
2785         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, label, labelLen);
2786         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, random1, random1Len);
2787         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, random2, random2Len);
2788         CHECK_MBEDTLS_RET(mbedtls_md_hmac_finish, &hmacP, tmp);
2789
2790         len += dLen;
2791
2792         memcpy(buf, tmp, dLen);
2793         buf += dLen;
2794
2795         CHECK_MBEDTLS_RET(mbedtls_md_hmac_reset, &hmacA);
2796         CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacA, key, keyLen);
2797         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacA, A, dLen);
2798         CHECK_MBEDTLS_RET(mbedtls_md_hmac_finish, &hmacA, A);
2799     }
2800
2801     if ((bufLen % dLen) != 0)
2802     {
2803         CHECK_MBEDTLS_RET(mbedtls_md_hmac_reset, &hmacP);
2804         CHECK_MBEDTLS_RET(mbedtls_md_hmac_starts, &hmacP, key, keyLen);
2805         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, A, dLen);
2806         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, label, labelLen);
2807         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, random1, random1Len);
2808         CHECK_MBEDTLS_RET(mbedtls_md_hmac_update, &hmacP, random2, random2Len);
2809         CHECK_MBEDTLS_RET(mbedtls_md_hmac_finish, &hmacP, tmp);
2810
2811         memcpy(buf, tmp, bufLen - len);
2812     }
2813
2814     mbedtls_md_free(&hmacA);
2815     mbedtls_md_free(&hmacP);
2816     return (int)bufLen;
2817     // exit label required for CHECK_MBEDTLS_RET macro
2818 exit:
2819     mbedtls_md_free(&hmacA);
2820     mbedtls_md_free(&hmacP);
2821     return -1;
2822 }
2823
2824 CAResult_t CAsslGenerateOwnerPsk(const CAEndpoint_t *endpoint,
2825                             const uint8_t* label, const size_t labelLen,
2826                             const uint8_t* rsrcServerDeviceId, const size_t rsrcServerDeviceIdLen,
2827                             const uint8_t* provServerDeviceId, const size_t provServerDeviceIdLen,
2828                             uint8_t* ownerPsk, const size_t ownerPskSize)
2829 {
2830     OIC_LOG_V(DEBUG, NET_SSL_TAG, "In %s", __func__);
2831     VERIFY_NON_NULL_RET(endpoint, NET_SSL_TAG, "endpoint is NULL", CA_STATUS_INVALID_PARAM);
2832     VERIFY_NON_NULL_RET(label, NET_SSL_TAG, "label is NULL", CA_STATUS_INVALID_PARAM);
2833     VERIFY_NON_NULL_RET(rsrcServerDeviceId, NET_SSL_TAG, "rsrcId is NULL", CA_STATUS_INVALID_PARAM);
2834     VERIFY_NON_NULL_RET(provServerDeviceId, NET_SSL_TAG, "provId is NULL", CA_STATUS_INVALID_PARAM);
2835     VERIFY_NON_NULL_RET(ownerPsk, NET_SSL_TAG, "ownerPSK is NULL", CA_STATUS_INVALID_PARAM);
2836
2837     oc_mutex_lock(g_sslContextMutex);
2838     if (NULL == g_caSslContext)
2839     {
2840         OIC_LOG(ERROR, NET_SSL_TAG, "Context is NULL");
2841         oc_mutex_unlock(g_sslContextMutex);
2842         OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2843         return CA_STATUS_FAILED;
2844     }
2845     SslEndPoint_t * tep = GetSslPeer(endpoint);
2846     if (NULL == tep)
2847     {
2848         OIC_LOG(ERROR, NET_SSL_TAG, "Session does not exist");
2849         oc_mutex_unlock(g_sslContextMutex);
2850         return CA_STATUS_FAILED;
2851     }
2852
2853     // keyBlockLen set up according to OIC 1.1 Security Specification Section 7.3.2
2854     int macKeyLen = 0;
2855     int ivSize = 0;
2856     int keySize = 0;
2857     int keyBlockLen = 0;
2858     if (MBEDTLS_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA256 == g_caSslContext->selectedCipher ||
2859         MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 == g_caSslContext->selectedCipher ||
2860         MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 == g_caSslContext->selectedCipher ||
2861         MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 == g_caSslContext->selectedCipher)
2862     {
2863         // 2 * ( 32 + 0 + 16 ) = 96
2864         macKeyLen = SHA256_MAC_KEY_LENGTH;
2865         ivSize = CBC_IV_LENGTH;
2866         keySize = AES128_KEY_LENGTH;
2867     }
2868     else if (MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM == g_caSslContext->selectedCipher ||
2869              MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8 == g_caSslContext->selectedCipher)
2870     {
2871         // 2 * ( 0 + 4 + 16 ) = 40
2872         macKeyLen = CCM_MAC_KEY_LENGTH;
2873         ivSize = CCM_IV_LENGTH;
2874         keySize = AES128_KEY_LENGTH;
2875     }
2876     else if (MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 == g_caSslContext->selectedCipher)
2877     {
2878         // 2 * ( 32 + 12 + 16 ) = 120
2879         macKeyLen = SHA256_MAC_KEY_LENGTH;
2880         ivSize = GCM_IV_LENGTH;
2881         keySize = AES128_KEY_LENGTH;
2882     }
2883     else if (MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA256 == g_caSslContext->selectedCipher)
2884     {
2885         // 2 * ( 32 + 0 + 32 ) = 128
2886         macKeyLen = SHA256_MAC_KEY_LENGTH;
2887         ivSize = CBC_IV_LENGTH;
2888         keySize = AES256_KEY_LENGTH;
2889     }
2890     else if (MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 == g_caSslContext->selectedCipher)
2891     {
2892         // 2 * ( 48 + 0 + 32 ) = 160
2893         macKeyLen = SHA384_MAC_KEY_LENGTH;
2894         ivSize = CBC_IV_LENGTH;
2895         keySize = AES256_KEY_LENGTH;
2896     }
2897     else if (MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 == g_caSslContext->selectedCipher)
2898     {
2899         // 2 * ( 48 + 12 + 32 ) = 184
2900         macKeyLen = SHA384_MAC_KEY_LENGTH;
2901         ivSize = GCM_IV_LENGTH;
2902         keySize = AES256_KEY_LENGTH;
2903     }
2904     else if (MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256 == g_caSslContext->selectedCipher)
2905     {
2906         // 2 * ( 48 + 12 + 32 ) = 184
2907         macKeyLen = SHA256_MAC_KEY_LENGTH;
2908         ivSize = GCM_IV_LENGTH;
2909         keySize = AES128_KEY_LENGTH;
2910     }
2911     keyBlockLen = 2 * (macKeyLen + keySize + ivSize);
2912
2913     uint8_t * keyblock = (uint8_t *)OICMalloc(keyBlockLen);
2914     if (NULL == keyblock)
2915     {
2916         OIC_LOG(ERROR, NET_SSL_TAG, "Failed to OICMalloc for keyblock");
2917         oc_mutex_unlock(g_sslContextMutex);
2918         return CA_STATUS_FAILED;
2919     }
2920
2921     // "key expansion"
2922     uint8_t lab[] = {0x6b, 0x65, 0x79, 0x20, 0x65, 0x78, 0x70, 0x61, 0x6e, 0x73, 0x69, 0x6f, 0x6e};
2923     int ret = pHash(tep->master, sizeof(tep->master), lab, sizeof(lab),
2924                     (tep->random) + RANDOM_LEN, RANDOM_LEN, tep->random, RANDOM_LEN,
2925                     keyblock, keyBlockLen);
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     ret = pHash(keyblock, keyBlockLen, label, labelLen,
2935                 rsrcServerDeviceId, rsrcServerDeviceIdLen,
2936                 provServerDeviceId, provServerDeviceIdLen,
2937                 ownerPsk, ownerPskSize);
2938     if (-1 == ret)
2939     {
2940         OIC_LOG(ERROR, NET_SSL_TAG, "PSK not generated");
2941         OICFree(keyblock);
2942         oc_mutex_unlock(g_sslContextMutex);
2943         return CA_STATUS_FAILED;
2944     }
2945
2946     OICFree(keyblock);
2947     oc_mutex_unlock(g_sslContextMutex);
2948
2949     OIC_LOG_V(DEBUG, NET_SSL_TAG, "Out %s", __func__);
2950     return CA_STATUS_OK;
2951 }