[IOT-2539] Clean sign-compare warnings
[iotivity.git] / resource / csdk / connectivity / test / ssladapter_test.cpp
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 // Warning disabled globally but VS2013 ignores the /wd4200 option in C++ files.
22 #if defined(_MSC_VER) && _MSC_VER < 1900
23 #pragma warning(disable : 4200)
24 #endif
25
26 #include <cinttypes>
27 #include "iotivity_config.h"
28 #include <gtest/gtest.h>
29 #include "time.h"
30 #include "octypes.h"
31 #ifdef HAVE_WINSOCK2_H
32 #include <winsock2.h>
33 #endif
34
35 // Test function hooks
36 #define CAcloseSslConnection CAcloseSslConnectionTest
37 #define CAdecryptSsl CAdecryptSslTest
38 #define CAdeinitSslAdapter CAdeinitSslAdapterTest
39 #define CAencryptSsl CAencryptSslTest
40 #define CAinitSslAdapter CAinitSslAdapterTest
41 #define CAinitiateSslHandshake CAinitiateSslHandshakeTest
42 #define CAsetCredentialTypesCallback CAsetCredentialTypesCallbackTest
43 #define CAsetSslAdapterCallbacks CAsetSslAdapterCallbacksTest
44 #define CAsetSslHandshakeCallback CAsetSslHandshakeCallbackTest
45 #define CAsetTlsCipherSuite CAsetTlsCipherSuiteTest
46 #define CAsslGenerateOwnerPsk CAsslGenerateOwnerPskTest
47 #define CAcloseSslConnectionAll CAcloseSslConnectionAllTest
48 #define GetCASecureEndpointData GetCASecureEndpointDataTest
49 #define SetCASecureEndpointAttribute SetCASecureEndpointAttributeTest
50 #define GetCASecureEndpointAttributes GetCASecureEndpointAttributesTest
51
52 #include "../src/adapter_util/ca_adapter_net_ssl.c"
53
54 #ifdef HAVE_UNISTD_H
55 #include <unistd.h>
56 #endif
57 #ifdef HAVE_PTHREAD_H
58 #include <pthread.h>
59 #endif
60 #include <stdio.h>
61 #include <stdlib.h>
62 #include <string.h>
63 #ifdef HAVE_SYS_TYPES_H
64 #include <sys/types.h>
65 #endif
66 #ifdef HAVE_SYS_SOCKET_H
67 #include <sys/socket.h>
68 #endif
69 #ifdef HAVE_NETINET_IN_H
70 #include <netinet/in.h>
71 #endif
72 #ifdef HAVE_NETDB_H
73 #include <netdb.h>
74 #endif
75
76 #if defined(_WIN32)
77 #include "pthread_create.h"
78 #endif
79 #ifdef HAVE_WINDOWS_H
80 #include <windows.h>
81 /** @todo stop-gap for naming issue. Windows.h does not like us to use ERROR */
82 #ifdef ERROR
83 #undef ERROR
84 #endif //ERROR
85 #endif //HAVE_WINDOWS_H
86 #include "platform_features.h"
87 #include "logger.h"
88
89
90 #define SEED "PREDICTED_SEED"
91 #define dummyHandler 0xF123
92
93 #define DEFAULT_HEX_WIDTH 16
94
95 #define SERVER_PORT 4433
96 #define SERVER_PORT_STRING "4433"
97 #define SERVER_NAME "localhost"
98 #define GET_REQUEST "GET / HTTP/1.0\r\n\r\n"
99
100 /* **************************
101  *
102  *
103  * Common routines
104  *
105  *
106  * *************************/
107
108 // Data blob contains 7 certificates in PEM and DER encoding
109 unsigned char certChain[] = {
110     // PEM encoded certificate
111     0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x43, 0x45, 0x52, 0x54, 0x49,
112     0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x43,
113     0x6e, 0x44, 0x43, 0x43, 0x41, 0x6a, 0x2b, 0x67, 0x41, 0x77, 0x49, 0x42, 0x41, 0x67, 0x49, 0x55,
114     0x44, 0x67, 0x45, 0x38, 0x4e, 0x50, 0x54, 0x4c, 0x46, 0x64, 0x6d, 0x68, 0x75, 0x72, 0x53, 0x69,
115     0x36, 0x33, 0x49, 0x31, 0x41, 0x77, 0x76, 0x37, 0x39, 0x49, 0x6b, 0x77, 0x44, 0x41, 0x59, 0x49,
116     0x4b, 0x6f, 0x5a, 0x49, 0x7a, 0x6a, 0x30, 0x45, 0x41, 0x77, 0x49, 0x46, 0x0a, 0x41, 0x44, 0x43,
117     0x42, 0x67, 0x7a, 0x45, 0x34, 0x4d, 0x44, 0x59, 0x47, 0x41, 0x31, 0x55, 0x45, 0x41, 0x78, 0x4d,
118     0x76, 0x55, 0x32, 0x46, 0x74, 0x63, 0x33, 0x56, 0x75, 0x5a, 0x79, 0x42, 0x46, 0x62, 0x47, 0x56,
119     0x6a, 0x64, 0x48, 0x4a, 0x76, 0x62, 0x6d, 0x6c, 0x6a, 0x63, 0x79, 0x42, 0x50, 0x51, 0x30, 0x59,
120     0x67, 0x54, 0x55, 0x4d, 0x67, 0x52, 0x47, 0x56, 0x32, 0x61, 0x57, 0x4e, 0x6c, 0x0a, 0x49, 0x46,
121     0x4e, 0x31, 0x59, 0x6b, 0x4e, 0x42, 0x49, 0x48, 0x59, 0x78, 0x49, 0x46, 0x52, 0x46, 0x55, 0x31,
122     0x51, 0x78, 0x48, 0x44, 0x41, 0x61, 0x42, 0x67, 0x4e, 0x56, 0x42, 0x41, 0x73, 0x54, 0x45, 0x30,
123     0x39, 0x44, 0x52, 0x69, 0x42, 0x4e, 0x51, 0x79, 0x42, 0x45, 0x5a, 0x58, 0x5a, 0x70, 0x59, 0x32,
124     0x55, 0x67, 0x55, 0x33, 0x56, 0x69, 0x51, 0x30, 0x45, 0x78, 0x48, 0x44, 0x41, 0x61, 0x0a, 0x42,
125     0x67, 0x4e, 0x56, 0x42, 0x41, 0x6f, 0x54, 0x45, 0x31, 0x4e, 0x68, 0x62, 0x58, 0x4e, 0x31, 0x62,
126     0x6d, 0x63, 0x67, 0x52, 0x57, 0x78, 0x6c, 0x59, 0x33, 0x52, 0x79, 0x62, 0x32, 0x35, 0x70, 0x59,
127     0x33, 0x4d, 0x78, 0x43, 0x7a, 0x41, 0x4a, 0x42, 0x67, 0x4e, 0x56, 0x42, 0x41, 0x59, 0x54, 0x41,
128     0x6b, 0x74, 0x53, 0x4d, 0x43, 0x41, 0x58, 0x44, 0x54, 0x45, 0x32, 0x4d, 0x54, 0x45, 0x79, 0x0a,
129     0x4e, 0x44, 0x41, 0x79, 0x4e, 0x44, 0x67, 0x78, 0x4d, 0x6c, 0x6f, 0x59, 0x44, 0x7a, 0x49, 0x77,
130     0x4e, 0x6a, 0x6b, 0x78, 0x4d, 0x6a, 0x4d, 0x78, 0x4d, 0x54, 0x51, 0x31, 0x4f, 0x54, 0x55, 0x35,
131     0x57, 0x6a, 0x43, 0x42, 0x6a, 0x54, 0x46, 0x49, 0x4d, 0x45, 0x59, 0x47, 0x41, 0x31, 0x55, 0x45,
132     0x41, 0x78, 0x4d, 0x2f, 0x54, 0x30, 0x4e, 0x47, 0x49, 0x45, 0x52, 0x6c, 0x64, 0x6d, 0x6c, 0x6a,
133     0x0a, 0x5a, 0x53, 0x42, 0x55, 0x52, 0x56, 0x4e, 0x55, 0x4f, 0x69, 0x42, 0x4f, 0x5a, 0x58, 0x52,
134     0x33, 0x62, 0x33, 0x4a, 0x72, 0x49, 0x43, 0x67, 0x77, 0x4e, 0x6a, 0x51, 0x79, 0x4e, 0x32, 0x45,
135     0x32, 0x4e, 0x53, 0x31, 0x69, 0x5a, 0x6a, 0x63, 0x30, 0x4c, 0x54, 0x51, 0x33, 0x4d, 0x7a, 0x63,
136     0x74, 0x4f, 0x54, 0x5a, 0x6d, 0x4d, 0x53, 0x30, 0x78, 0x59, 0x6d, 0x49, 0x78, 0x4f, 0x44, 0x5a,
137     0x6b, 0x0a, 0x4f, 0x47, 0x59, 0x33, 0x59, 0x6a, 0x4d, 0x70, 0x4d, 0x52, 0x59, 0x77, 0x46, 0x41,
138     0x59, 0x44, 0x56, 0x51, 0x51, 0x4c, 0x45, 0x77, 0x31, 0x50, 0x51, 0x30, 0x59, 0x67, 0x54, 0x55,
139     0x4d, 0x67, 0x52, 0x47, 0x56, 0x32, 0x61, 0x57, 0x4e, 0x6c, 0x4d, 0x52, 0x77, 0x77, 0x47, 0x67,
140     0x59, 0x44, 0x56, 0x51, 0x51, 0x4b, 0x45, 0x78, 0x4e, 0x54, 0x59, 0x57, 0x31, 0x7a, 0x64, 0x57,
141     0x35, 0x6e, 0x0a, 0x49, 0x45, 0x56, 0x73, 0x5a, 0x57, 0x4e, 0x30, 0x63, 0x6d, 0x39, 0x75, 0x61,
142     0x57, 0x4e, 0x7a, 0x4d, 0x51, 0x73, 0x77, 0x43, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x47, 0x45,
143     0x77, 0x4a, 0x4c, 0x55, 0x6a, 0x42, 0x5a, 0x4d, 0x42, 0x4d, 0x47, 0x42, 0x79, 0x71, 0x47, 0x53,
144     0x4d, 0x34, 0x39, 0x41, 0x67, 0x45, 0x47, 0x43, 0x43, 0x71, 0x47, 0x53, 0x4d, 0x34, 0x39, 0x41,
145     0x77, 0x45, 0x48, 0x0a, 0x41, 0x30, 0x49, 0x41, 0x42, 0x45, 0x45, 0x77, 0x51, 0x41, 0x52, 0x73,
146     0x62, 0x67, 0x43, 0x59, 0x2b, 0x43, 0x59, 0x6b, 0x49, 0x6a, 0x6b, 0x59, 0x6f, 0x47, 0x78, 0x6f,
147     0x52, 0x33, 0x75, 0x70, 0x33, 0x38, 0x59, 0x47, 0x54, 0x32, 0x63, 0x4b, 0x30, 0x31, 0x74, 0x6d,
148     0x32, 0x70, 0x38, 0x79, 0x4c, 0x4b, 0x4e, 0x73, 0x6d, 0x69, 0x53, 0x6f, 0x76, 0x46, 0x70, 0x4a,
149     0x32, 0x35, 0x63, 0x52, 0x0a, 0x74, 0x72, 0x57, 0x34, 0x41, 0x56, 0x7a, 0x76, 0x73, 0x64, 0x67,
150     0x62, 0x74, 0x72, 0x45, 0x62, 0x6b, 0x2b, 0x37, 0x73, 0x56, 0x61, 0x58, 0x50, 0x74, 0x78, 0x43,
151     0x6a, 0x67, 0x59, 0x41, 0x77, 0x66, 0x6a, 0x41, 0x4f, 0x42, 0x67, 0x4e, 0x56, 0x48, 0x51, 0x38,
152     0x42, 0x41, 0x66, 0x38, 0x45, 0x42, 0x41, 0x4d, 0x43, 0x41, 0x38, 0x67, 0x77, 0x4c, 0x67, 0x59,
153     0x44, 0x56, 0x52, 0x30, 0x66, 0x0a, 0x42, 0x43, 0x63, 0x77, 0x4a, 0x54, 0x41, 0x6a, 0x6f, 0x43,
154     0x47, 0x67, 0x48, 0x34, 0x59, 0x64, 0x61, 0x48, 0x52, 0x30, 0x63, 0x44, 0x6f, 0x76, 0x4c, 0x32,
155     0x4e, 0x68, 0x4c, 0x6e, 0x4e, 0x68, 0x62, 0x58, 0x4e, 0x31, 0x62, 0x6d, 0x64, 0x70, 0x62, 0x33,
156     0x52, 0x7a, 0x4c, 0x6d, 0x4e, 0x76, 0x62, 0x53, 0x39, 0x6a, 0x63, 0x6d, 0x77, 0x77, 0x50, 0x41,
157     0x59, 0x49, 0x4b, 0x77, 0x59, 0x42, 0x0a, 0x42, 0x51, 0x55, 0x48, 0x41, 0x51, 0x45, 0x45, 0x4d,
158     0x44, 0x41, 0x75, 0x4d, 0x43, 0x77, 0x47, 0x43, 0x43, 0x73, 0x47, 0x41, 0x51, 0x55, 0x46, 0x42,
159     0x7a, 0x41, 0x42, 0x68, 0x69, 0x42, 0x6f, 0x64, 0x48, 0x52, 0x77, 0x4f, 0x69, 0x38, 0x76, 0x62,
160     0x32, 0x4e, 0x7a, 0x63, 0x43, 0x31, 0x30, 0x5a, 0x58, 0x4e, 0x30, 0x4c, 0x6e, 0x4e, 0x68, 0x62,
161     0x58, 0x4e, 0x31, 0x62, 0x6d, 0x64, 0x70, 0x0a, 0x62, 0x33, 0x52, 0x7a, 0x4c, 0x6d, 0x4e, 0x76,
162     0x62, 0x54, 0x41, 0x4d, 0x42, 0x67, 0x67, 0x71, 0x68, 0x6b, 0x6a, 0x4f, 0x50, 0x51, 0x51, 0x44,
163     0x41, 0x67, 0x55, 0x41, 0x41, 0x30, 0x6b, 0x41, 0x4d, 0x45, 0x59, 0x43, 0x49, 0x51, 0x43, 0x33,
164     0x58, 0x30, 0x42, 0x61, 0x4f, 0x49, 0x6f, 0x63, 0x4b, 0x4f, 0x45, 0x65, 0x44, 0x46, 0x52, 0x6b,
165     0x63, 0x66, 0x30, 0x48, 0x76, 0x68, 0x68, 0x67, 0x0a, 0x73, 0x6c, 0x65, 0x49, 0x52, 0x32, 0x49,
166     0x62, 0x6d, 0x66, 0x34, 0x6e, 0x69, 0x52, 0x52, 0x55, 0x38, 0x41, 0x49, 0x68, 0x41, 0x4f, 0x4d,
167     0x44, 0x31, 0x77, 0x45, 0x62, 0x50, 0x67, 0x34, 0x70, 0x47, 0x77, 0x49, 0x79, 0x65, 0x77, 0x63,
168     0x61, 0x6b, 0x76, 0x72, 0x4e, 0x4b, 0x66, 0x44, 0x79, 0x2b, 0x4f, 0x4e, 0x43, 0x6e, 0x4e, 0x6e,
169     0x43, 0x59, 0x57, 0x4a, 0x37, 0x39, 0x35, 0x4b, 0x49, 0x0a, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x45,
170     0x4e, 0x44, 0x20, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d,
171     0x2d, 0x2d, 0x2d,
172     // PEM encoded certificate
173     0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x43, 0x45, 0x52, 0x54, 0x49,
174     0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x43,
175     0x6e, 0x44, 0x43, 0x43, 0x41, 0x6a, 0x2b, 0x67, 0x41, 0x77, 0x49, 0x42, 0x41, 0x67, 0x49, 0x55,
176     0x44, 0x67, 0x45, 0x38, 0x4e, 0x50, 0x54, 0x4c, 0x46, 0x64, 0x6d, 0x68, 0x75, 0x72, 0x53, 0x69,
177     0x36, 0x33, 0x49, 0x31, 0x41, 0x77, 0x76, 0x37, 0x39, 0x49, 0x6b, 0x77, 0x44, 0x41, 0x59, 0x49,
178     0x4b, 0x6f, 0x5a, 0x49, 0x7a, 0x6a, 0x30, 0x45, 0x41, 0x77, 0x49, 0x46, 0x0a, 0x41, 0x44, 0x43,
179     0x42, 0x67, 0x7a, 0x45, 0x34, 0x4d, 0x44, 0x59, 0x47, 0x41, 0x31, 0x55, 0x45, 0x41, 0x78, 0x4d,
180     0x76, 0x55, 0x32, 0x46, 0x74, 0x63, 0x33, 0x56, 0x75, 0x5a, 0x79, 0x42, 0x46, 0x62, 0x47, 0x56,
181     0x6a, 0x64, 0x48, 0x4a, 0x76, 0x62, 0x6d, 0x6c, 0x6a, 0x63, 0x79, 0x42, 0x50, 0x51, 0x30, 0x59,
182     0x67, 0x54, 0x55, 0x4d, 0x67, 0x52, 0x47, 0x56, 0x32, 0x61, 0x57, 0x4e, 0x6c, 0x0a, 0x49, 0x46,
183     0x4e, 0x31, 0x59, 0x6b, 0x4e, 0x42, 0x49, 0x48, 0x59, 0x78, 0x49, 0x46, 0x52, 0x46, 0x55, 0x31,
184     0x51, 0x78, 0x48, 0x44, 0x41, 0x61, 0x42, 0x67, 0x4e, 0x56, 0x42, 0x41, 0x73, 0x54, 0x45, 0x30,
185     0x39, 0x44, 0x52, 0x69, 0x42, 0x4e, 0x51, 0x79, 0x42, 0x45, 0x5a, 0x58, 0x5a, 0x70, 0x59, 0x32,
186     0x55, 0x67, 0x55, 0x33, 0x56, 0x69, 0x51, 0x30, 0x45, 0x78, 0x48, 0x44, 0x41, 0x61, 0x0a, 0x42,
187     0x67, 0x4e, 0x56, 0x42, 0x41, 0x6f, 0x54, 0x45, 0x31, 0x4e, 0x68, 0x62, 0x58, 0x4e, 0x31, 0x62,
188     0x6d, 0x63, 0x67, 0x52, 0x57, 0x78, 0x6c, 0x59, 0x33, 0x52, 0x79, 0x62, 0x32, 0x35, 0x70, 0x59,
189     0x33, 0x4d, 0x78, 0x43, 0x7a, 0x41, 0x4a, 0x42, 0x67, 0x4e, 0x56, 0x42, 0x41, 0x59, 0x54, 0x41,
190     0x6b, 0x74, 0x53, 0x4d, 0x43, 0x41, 0x58, 0x44, 0x54, 0x45, 0x32, 0x4d, 0x54, 0x45, 0x79, 0x0a,
191     0x4e, 0x44, 0x41, 0x79, 0x4e, 0x44, 0x67, 0x78, 0x4d, 0x6c, 0x6f, 0x59, 0x44, 0x7a, 0x49, 0x77,
192     0x4e, 0x6a, 0x6b, 0x78, 0x4d, 0x6a, 0x4d, 0x78, 0x4d, 0x54, 0x51, 0x31, 0x4f, 0x54, 0x55, 0x35,
193     0x57, 0x6a, 0x43, 0x42, 0x6a, 0x54, 0x46, 0x49, 0x4d, 0x45, 0x59, 0x47, 0x41, 0x31, 0x55, 0x45,
194     0x41, 0x78, 0x4d, 0x2f, 0x54, 0x30, 0x4e, 0x47, 0x49, 0x45, 0x52, 0x6c, 0x64, 0x6d, 0x6c, 0x6a,
195     0x0a, 0x5a, 0x53, 0x42, 0x55, 0x52, 0x56, 0x4e, 0x55, 0x4f, 0x69, 0x42, 0x4f, 0x5a, 0x58, 0x52,
196     0x33, 0x62, 0x33, 0x4a, 0x72, 0x49, 0x43, 0x67, 0x77, 0x4e, 0x6a, 0x51, 0x79, 0x4e, 0x32, 0x45,
197     0x32, 0x4e, 0x53, 0x31, 0x69, 0x5a, 0x6a, 0x63, 0x30, 0x4c, 0x54, 0x51, 0x33, 0x4d, 0x7a, 0x63,
198     0x74, 0x4f, 0x54, 0x5a, 0x6d, 0x4d, 0x53, 0x30, 0x78, 0x59, 0x6d, 0x49, 0x78, 0x4f, 0x44, 0x5a,
199     0x6b, 0x0a, 0x4f, 0x47, 0x59, 0x33, 0x59, 0x6a, 0x4d, 0x70, 0x4d, 0x52, 0x59, 0x77, 0x46, 0x41,
200     0x59, 0x44, 0x56, 0x51, 0x51, 0x4c, 0x45, 0x77, 0x31, 0x50, 0x51, 0x30, 0x59, 0x67, 0x54, 0x55,
201     0x4d, 0x67, 0x52, 0x47, 0x56, 0x32, 0x61, 0x57, 0x4e, 0x6c, 0x4d, 0x52, 0x77, 0x77, 0x47, 0x67,
202     0x59, 0x44, 0x56, 0x51, 0x51, 0x4b, 0x45, 0x78, 0x4e, 0x54, 0x59, 0x57, 0x31, 0x7a, 0x64, 0x57,
203     0x35, 0x6e, 0x0a, 0x49, 0x45, 0x56, 0x73, 0x5a, 0x57, 0x4e, 0x30, 0x63, 0x6d, 0x39, 0x75, 0x61,
204     0x57, 0x4e, 0x7a, 0x4d, 0x51, 0x73, 0x77, 0x43, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x47, 0x45,
205     0x77, 0x4a, 0x4c, 0x55, 0x6a, 0x42, 0x5a, 0x4d, 0x42, 0x4d, 0x47, 0x42, 0x79, 0x71, 0x47, 0x53,
206     0x4d, 0x34, 0x39, 0x41, 0x67, 0x45, 0x47, 0x43, 0x43, 0x71, 0x47, 0x53, 0x4d, 0x34, 0x39, 0x41,
207     0x77, 0x45, 0x48, 0x0a, 0x41, 0x30, 0x49, 0x41, 0x42, 0x45, 0x45, 0x77, 0x51, 0x41, 0x52, 0x73,
208     0x62, 0x67, 0x43, 0x59, 0x2b, 0x43, 0x59, 0x6b, 0x49, 0x6a, 0x6b, 0x59, 0x6f, 0x47, 0x78, 0x6f,
209     0x52, 0x33, 0x75, 0x70, 0x33, 0x38, 0x59, 0x47, 0x54, 0x32, 0x63, 0x4b, 0x30, 0x31, 0x74, 0x6d,
210     0x32, 0x70, 0x38, 0x79, 0x4c, 0x4b, 0x4e, 0x73, 0x6d, 0x69, 0x53, 0x6f, 0x76, 0x46, 0x70, 0x4a,
211     0x32, 0x35, 0x63, 0x52, 0x0a, 0x74, 0x72, 0x57, 0x34, 0x41, 0x56, 0x7a, 0x76, 0x73, 0x64, 0x67,
212     0x62, 0x74, 0x72, 0x45, 0x62, 0x6b, 0x2b, 0x37, 0x73, 0x56, 0x61, 0x58, 0x50, 0x74, 0x78, 0x43,
213     0x6a, 0x67, 0x59, 0x41, 0x77, 0x66, 0x6a, 0x41, 0x4f, 0x42, 0x67, 0x4e, 0x56, 0x48, 0x51, 0x38,
214     0x42, 0x41, 0x66, 0x38, 0x45, 0x42, 0x41, 0x4d, 0x43, 0x41, 0x38, 0x67, 0x77, 0x4c, 0x67, 0x59,
215     0x44, 0x56, 0x52, 0x30, 0x66, 0x0a, 0x42, 0x43, 0x63, 0x77, 0x4a, 0x54, 0x41, 0x6a, 0x6f, 0x43,
216     0x47, 0x67, 0x48, 0x34, 0x59, 0x64, 0x61, 0x48, 0x52, 0x30, 0x63, 0x44, 0x6f, 0x76, 0x4c, 0x32,
217     0x4e, 0x68, 0x4c, 0x6e, 0x4e, 0x68, 0x62, 0x58, 0x4e, 0x31, 0x62, 0x6d, 0x64, 0x70, 0x62, 0x33,
218     0x52, 0x7a, 0x4c, 0x6d, 0x4e, 0x76, 0x62, 0x53, 0x39, 0x6a, 0x63, 0x6d, 0x77, 0x77, 0x50, 0x41,
219     0x59, 0x49, 0x4b, 0x77, 0x59, 0x42, 0x0a, 0x42, 0x51, 0x55, 0x48, 0x41, 0x51, 0x45, 0x45, 0x4d,
220     0x44, 0x41, 0x75, 0x4d, 0x43, 0x77, 0x47, 0x43, 0x43, 0x73, 0x47, 0x41, 0x51, 0x55, 0x46, 0x42,
221     0x7a, 0x41, 0x42, 0x68, 0x69, 0x42, 0x6f, 0x64, 0x48, 0x52, 0x77, 0x4f, 0x69, 0x38, 0x76, 0x62,
222     0x32, 0x4e, 0x7a, 0x63, 0x43, 0x31, 0x30, 0x5a, 0x58, 0x4e, 0x30, 0x4c, 0x6e, 0x4e, 0x68, 0x62,
223     0x58, 0x4e, 0x31, 0x62, 0x6d, 0x64, 0x70, 0x0a, 0x62, 0x33, 0x52, 0x7a, 0x4c, 0x6d, 0x4e, 0x76,
224     0x62, 0x54, 0x41, 0x4d, 0x42, 0x67, 0x67, 0x71, 0x68, 0x6b, 0x6a, 0x4f, 0x50, 0x51, 0x51, 0x44,
225     0x41, 0x67, 0x55, 0x41, 0x41, 0x30, 0x6b, 0x41, 0x4d, 0x45, 0x59, 0x43, 0x49, 0x51, 0x43, 0x33,
226     0x58, 0x30, 0x42, 0x61, 0x4f, 0x49, 0x6f, 0x63, 0x4b, 0x4f, 0x45, 0x65, 0x44, 0x46, 0x52, 0x6b,
227     0x63, 0x66, 0x30, 0x48, 0x76, 0x68, 0x68, 0x67, 0x0a, 0x73, 0x6c, 0x65, 0x49, 0x52, 0x32, 0x49,
228     0x62, 0x6d, 0x66, 0x34, 0x6e, 0x69, 0x52, 0x52, 0x55, 0x38, 0x41, 0x49, 0x68, 0x41, 0x4f, 0x4d,
229     0x44, 0x31, 0x77, 0x45, 0x62, 0x50, 0x67, 0x34, 0x70, 0x47, 0x77, 0x49, 0x79, 0x65, 0x77, 0x63,
230     0x61, 0x6b, 0x76, 0x72, 0x4e, 0x4b, 0x66, 0x44, 0x79, 0x2b, 0x4f, 0x4e, 0x43, 0x6e, 0x4e, 0x6e,
231     0x43, 0x59, 0x57, 0x4a, 0x37, 0x39, 0x35, 0x4b, 0x49, 0x0a, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x45,
232     0x4e, 0x44, 0x20, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d,
233     0x2d, 0x2d, 0x2d,
234     // PEM encoded certificate
235     0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x43, 0x45, 0x52, 0x54, 0x49,
236     0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0d, 0x0a, 0x4d, 0x49, 0x49,
237     0x45, 0x67, 0x44, 0x43, 0x43, 0x41, 0x32, 0x69, 0x67, 0x41, 0x77, 0x49, 0x42, 0x41, 0x67, 0x49,
238     0x49, 0x58, 0x32, 0x37, 0x50, 0x44, 0x4d, 0x55, 0x38, 0x2b, 0x66, 0x6f, 0x77, 0x44, 0x51, 0x59,
239     0x4a, 0x4b, 0x6f, 0x5a, 0x49, 0x68, 0x76, 0x63, 0x4e, 0x41, 0x51, 0x45, 0x4c, 0x42, 0x51, 0x41,
240     0x77, 0x53, 0x54, 0x45, 0x4c, 0x4d, 0x41, 0x6b, 0x47, 0x41, 0x31, 0x55, 0x45, 0x0d, 0x0a, 0x42,
241     0x68, 0x4d, 0x43, 0x56, 0x56, 0x4d, 0x78, 0x45, 0x7a, 0x41, 0x52, 0x42, 0x67, 0x4e, 0x56, 0x42,
242     0x41, 0x6f, 0x54, 0x43, 0x6b, 0x64, 0x76, 0x62, 0x32, 0x64, 0x73, 0x5a, 0x53, 0x42, 0x4a, 0x62,
243     0x6d, 0x4d, 0x78, 0x4a, 0x54, 0x41, 0x6a, 0x42, 0x67, 0x4e, 0x56, 0x42, 0x41, 0x4d, 0x54, 0x48,
244     0x45, 0x64, 0x76, 0x62, 0x32, 0x64, 0x73, 0x5a, 0x53, 0x42, 0x4a, 0x62, 0x6e, 0x52, 0x6c, 0x0d,
245     0x0a, 0x63, 0x6d, 0x35, 0x6c, 0x64, 0x43, 0x42, 0x42, 0x64, 0x58, 0x52, 0x6f, 0x62, 0x33, 0x4a,
246     0x70, 0x64, 0x48, 0x6b, 0x67, 0x52, 0x7a, 0x49, 0x77, 0x48, 0x68, 0x63, 0x4e, 0x4d, 0x54, 0x59,
247     0x78, 0x4d, 0x6a, 0x41, 0x78, 0x4d, 0x54, 0x51, 0x78, 0x4f, 0x44, 0x55, 0x32, 0x57, 0x68, 0x63,
248     0x4e, 0x4d, 0x54, 0x63, 0x77, 0x4d, 0x6a, 0x49, 0x7a, 0x4d, 0x54, 0x51, 0x78, 0x4e, 0x6a, 0x41,
249     0x77, 0x0d, 0x0a, 0x57, 0x6a, 0x42, 0x6f, 0x4d, 0x51, 0x73, 0x77, 0x43, 0x51, 0x59, 0x44, 0x56,
250     0x51, 0x51, 0x47, 0x45, 0x77, 0x4a, 0x56, 0x55, 0x7a, 0x45, 0x54, 0x4d, 0x42, 0x45, 0x47, 0x41,
251     0x31, 0x55, 0x45, 0x43, 0x41, 0x77, 0x4b, 0x51, 0x32, 0x46, 0x73, 0x61, 0x57, 0x5a, 0x76, 0x63,
252     0x6d, 0x35, 0x70, 0x59, 0x54, 0x45, 0x57, 0x4d, 0x42, 0x51, 0x47, 0x41, 0x31, 0x55, 0x45, 0x42,
253     0x77, 0x77, 0x4e, 0x0d, 0x0a, 0x54, 0x57, 0x39, 0x31, 0x62, 0x6e, 0x52, 0x68, 0x61, 0x57, 0x34,
254     0x67, 0x56, 0x6d, 0x6c, 0x6c, 0x64, 0x7a, 0x45, 0x54, 0x4d, 0x42, 0x45, 0x47, 0x41, 0x31, 0x55,
255     0x45, 0x43, 0x67, 0x77, 0x4b, 0x52, 0x32, 0x39, 0x76, 0x5a, 0x32, 0x78, 0x6c, 0x49, 0x45, 0x6c,
256     0x75, 0x59, 0x7a, 0x45, 0x58, 0x4d, 0x42, 0x55, 0x47, 0x41, 0x31, 0x55, 0x45, 0x41, 0x77, 0x77,
257     0x4f, 0x61, 0x57, 0x31, 0x68, 0x0d, 0x0a, 0x63, 0x43, 0x35, 0x6e, 0x62, 0x57, 0x46, 0x70, 0x62,
258     0x43, 0x35, 0x6a, 0x62, 0x32, 0x30, 0x77, 0x67, 0x67, 0x45, 0x69, 0x4d, 0x41, 0x30, 0x47, 0x43,
259     0x53, 0x71, 0x47, 0x53, 0x49, 0x62, 0x33, 0x44, 0x51, 0x45, 0x42, 0x41, 0x51, 0x55, 0x41, 0x41,
260     0x34, 0x49, 0x42, 0x44, 0x77, 0x41, 0x77, 0x67, 0x67, 0x45, 0x4b, 0x41, 0x6f, 0x49, 0x42, 0x41,
261     0x51, 0x43, 0x61, 0x57, 0x66, 0x7a, 0x79, 0x0d, 0x0a, 0x75, 0x59, 0x6e, 0x66, 0x4e, 0x69, 0x54,
262     0x54, 0x61, 0x50, 0x69, 0x33, 0x6b, 0x57, 0x63, 0x6b, 0x65, 0x44, 0x4e, 0x48, 0x78, 0x6f, 0x6f,
263     0x5a, 0x71, 0x4d, 0x31, 0x36, 0x5a, 0x37, 0x5a, 0x38, 0x38, 0x5a, 0x63, 0x48, 0x69, 0x78, 0x79,
264     0x74, 0x68, 0x63, 0x38, 0x4e, 0x6c, 0x31, 0x32, 0x59, 0x45, 0x66, 0x46, 0x78, 0x66, 0x51, 0x4e,
265     0x77, 0x73, 0x2f, 0x65, 0x41, 0x4b, 0x31, 0x66, 0x6a, 0x0d, 0x0a, 0x41, 0x43, 0x59, 0x54, 0x57,
266     0x39, 0x39, 0x63, 0x45, 0x36, 0x31, 0x4e, 0x51, 0x68, 0x59, 0x48, 0x6c, 0x51, 0x67, 0x78, 0x6f,
267     0x62, 0x49, 0x39, 0x50, 0x44, 0x66, 0x61, 0x4f, 0x7a, 0x36, 0x4e, 0x6b, 0x72, 0x66, 0x62, 0x61,
268     0x79, 0x61, 0x53, 0x7a, 0x77, 0x4a, 0x39, 0x44, 0x76, 0x4b, 0x64, 0x49, 0x52, 0x4f, 0x64, 0x58,
269     0x36, 0x6d, 0x70, 0x72, 0x53, 0x2b, 0x79, 0x4c, 0x56, 0x47, 0x32, 0x0d, 0x0a, 0x2f, 0x4f, 0x49,
270     0x51, 0x37, 0x72, 0x37, 0x48, 0x32, 0x65, 0x62, 0x77, 0x48, 0x6d, 0x69, 0x58, 0x6f, 0x33, 0x5a,
271     0x30, 0x50, 0x4b, 0x62, 0x6c, 0x66, 0x4b, 0x44, 0x4b, 0x6b, 0x63, 0x67, 0x4b, 0x4c, 0x31, 0x73,
272     0x6b, 0x33, 0x42, 0x51, 0x65, 0x78, 0x49, 0x78, 0x32, 0x4a, 0x31, 0x53, 0x51, 0x4a, 0x61, 0x32,
273     0x53, 0x66, 0x55, 0x6e, 0x46, 0x6e, 0x61, 0x70, 0x62, 0x4f, 0x6a, 0x4a, 0x2b, 0x0d, 0x0a, 0x4a,
274     0x42, 0x68, 0x77, 0x4f, 0x71, 0x68, 0x67, 0x36, 0x6b, 0x43, 0x4b, 0x70, 0x2b, 0x4a, 0x4e, 0x4e,
275     0x59, 0x44, 0x53, 0x44, 0x47, 0x4b, 0x57, 0x47, 0x76, 0x49, 0x45, 0x44, 0x7a, 0x6f, 0x55, 0x7a,
276     0x66, 0x37, 0x35, 0x36, 0x2f, 0x63, 0x58, 0x57, 0x34, 0x6d, 0x36, 0x34, 0x74, 0x44, 0x78, 0x39,
277     0x54, 0x33, 0x4d, 0x66, 0x4b, 0x65, 0x55, 0x6a, 0x77, 0x31, 0x30, 0x68, 0x41, 0x72, 0x6f, 0x0d,
278     0x0a, 0x63, 0x33, 0x37, 0x62, 0x4a, 0x64, 0x69, 0x2f, 0x46, 0x66, 0x6c, 0x34, 0x7a, 0x38, 0x2f,
279     0x43, 0x75, 0x56, 0x55, 0x4f, 0x4c, 0x36, 0x76, 0x55, 0x6e, 0x75, 0x55, 0x35, 0x75, 0x6e, 0x46,
280     0x6a, 0x67, 0x6d, 0x52, 0x6a, 0x36, 0x6e, 0x65, 0x47, 0x53, 0x63, 0x33, 0x57, 0x4a, 0x31, 0x79,
281     0x76, 0x76, 0x56, 0x32, 0x6e, 0x4f, 0x37, 0x41, 0x50, 0x4b, 0x6e, 0x43, 0x4f, 0x68, 0x6c, 0x4e,
282     0x7a, 0x0d, 0x0a, 0x6e, 0x7a, 0x45, 0x6f, 0x69, 0x73, 0x73, 0x68, 0x6d, 0x6c, 0x7a, 0x78, 0x43,
283     0x62, 0x4d, 0x76, 0x41, 0x67, 0x4d, 0x42, 0x41, 0x41, 0x47, 0x6a, 0x67, 0x67, 0x46, 0x4c, 0x4d,
284     0x49, 0x49, 0x42, 0x52, 0x7a, 0x41, 0x64, 0x42, 0x67, 0x4e, 0x56, 0x48, 0x53, 0x55, 0x45, 0x46,
285     0x6a, 0x41, 0x55, 0x42, 0x67, 0x67, 0x72, 0x42, 0x67, 0x45, 0x46, 0x42, 0x51, 0x63, 0x44, 0x41,
286     0x51, 0x59, 0x49, 0x0d, 0x0a, 0x4b, 0x77, 0x59, 0x42, 0x42, 0x51, 0x55, 0x48, 0x41, 0x77, 0x49,
287     0x77, 0x47, 0x51, 0x59, 0x44, 0x56, 0x52, 0x30, 0x52, 0x42, 0x42, 0x49, 0x77, 0x45, 0x49, 0x49,
288     0x4f, 0x61, 0x57, 0x31, 0x68, 0x63, 0x43, 0x35, 0x6e, 0x62, 0x57, 0x46, 0x70, 0x62, 0x43, 0x35,
289     0x6a, 0x62, 0x32, 0x30, 0x77, 0x61, 0x41, 0x59, 0x49, 0x4b, 0x77, 0x59, 0x42, 0x42, 0x51, 0x55,
290     0x48, 0x41, 0x51, 0x45, 0x45, 0x0d, 0x0a, 0x58, 0x44, 0x42, 0x61, 0x4d, 0x43, 0x73, 0x47, 0x43,
291     0x43, 0x73, 0x47, 0x41, 0x51, 0x55, 0x46, 0x42, 0x7a, 0x41, 0x43, 0x68, 0x68, 0x39, 0x6f, 0x64,
292     0x48, 0x52, 0x77, 0x4f, 0x69, 0x38, 0x76, 0x63, 0x47, 0x74, 0x70, 0x4c, 0x6d, 0x64, 0x76, 0x62,
293     0x32, 0x64, 0x73, 0x5a, 0x53, 0x35, 0x6a, 0x62, 0x32, 0x30, 0x76, 0x52, 0x30, 0x6c, 0x42, 0x52,
294     0x7a, 0x49, 0x75, 0x59, 0x33, 0x4a, 0x30, 0x0d, 0x0a, 0x4d, 0x43, 0x73, 0x47, 0x43, 0x43, 0x73,
295     0x47, 0x41, 0x51, 0x55, 0x46, 0x42, 0x7a, 0x41, 0x42, 0x68, 0x68, 0x39, 0x6f, 0x64, 0x48, 0x52,
296     0x77, 0x4f, 0x69, 0x38, 0x76, 0x59, 0x32, 0x78, 0x70, 0x5a, 0x57, 0x35, 0x30, 0x63, 0x7a, 0x45,
297     0x75, 0x5a, 0x32, 0x39, 0x76, 0x5a, 0x32, 0x78, 0x6c, 0x4c, 0x6d, 0x4e, 0x76, 0x62, 0x53, 0x39,
298     0x76, 0x59, 0x33, 0x4e, 0x77, 0x4d, 0x42, 0x30, 0x47, 0x0d, 0x0a, 0x41, 0x31, 0x55, 0x64, 0x44,
299     0x67, 0x51, 0x57, 0x42, 0x42, 0x52, 0x75, 0x74, 0x41, 0x41, 0x45, 0x4b, 0x70, 0x75, 0x65, 0x4c,
300     0x4f, 0x4c, 0x4b, 0x33, 0x64, 0x6e, 0x56, 0x2b, 0x75, 0x59, 0x47, 0x68, 0x77, 0x68, 0x58, 0x6d,
301     0x6a, 0x41, 0x4d, 0x42, 0x67, 0x4e, 0x56, 0x48, 0x52, 0x4d, 0x42, 0x41, 0x66, 0x38, 0x45, 0x41,
302     0x6a, 0x41, 0x41, 0x4d, 0x42, 0x38, 0x47, 0x41, 0x31, 0x55, 0x64, 0x0d, 0x0a, 0x49, 0x77, 0x51,
303     0x59, 0x4d, 0x42, 0x61, 0x41, 0x46, 0x45, 0x72, 0x64, 0x42, 0x68, 0x59, 0x62, 0x76, 0x50, 0x5a,
304     0x6f, 0x74, 0x58, 0x62, 0x31, 0x67, 0x62, 0x61, 0x37, 0x59, 0x68, 0x71, 0x36, 0x57, 0x6f, 0x45,
305     0x76, 0x4d, 0x43, 0x45, 0x47, 0x41, 0x31, 0x55, 0x64, 0x49, 0x41, 0x51, 0x61, 0x4d, 0x42, 0x67,
306     0x77, 0x44, 0x41, 0x59, 0x4b, 0x4b, 0x77, 0x59, 0x42, 0x42, 0x41, 0x48, 0x57, 0x0d, 0x0a, 0x65,
307     0x51, 0x49, 0x46, 0x41, 0x54, 0x41, 0x49, 0x42, 0x67, 0x5a, 0x6e, 0x67, 0x51, 0x77, 0x42, 0x41,
308     0x67, 0x49, 0x77, 0x4d, 0x41, 0x59, 0x44, 0x56, 0x52, 0x30, 0x66, 0x42, 0x43, 0x6b, 0x77, 0x4a,
309     0x7a, 0x41, 0x6c, 0x6f, 0x43, 0x4f, 0x67, 0x49, 0x59, 0x59, 0x66, 0x61, 0x48, 0x52, 0x30, 0x63,
310     0x44, 0x6f, 0x76, 0x4c, 0x33, 0x42, 0x72, 0x61, 0x53, 0x35, 0x6e, 0x62, 0x32, 0x39, 0x6e, 0x0d,
311     0x0a, 0x62, 0x47, 0x55, 0x75, 0x59, 0x32, 0x39, 0x74, 0x4c, 0x30, 0x64, 0x4a, 0x51, 0x55, 0x63,
312     0x79, 0x4c, 0x6d, 0x4e, 0x79, 0x62, 0x44, 0x41, 0x4e, 0x42, 0x67, 0x6b, 0x71, 0x68, 0x6b, 0x69,
313     0x47, 0x39, 0x77, 0x30, 0x42, 0x41, 0x51, 0x73, 0x46, 0x41, 0x41, 0x4f, 0x43, 0x41, 0x51, 0x45,
314     0x41, 0x58, 0x31, 0x7a, 0x42, 0x4a, 0x45, 0x2b, 0x6b, 0x4e, 0x2f, 0x39, 0x50, 0x42, 0x4a, 0x48,
315     0x59, 0x0d, 0x0a, 0x35, 0x74, 0x57, 0x62, 0x44, 0x57, 0x62, 0x75, 0x44, 0x63, 0x66, 0x32, 0x72,
316     0x31, 0x49, 0x35, 0x6f, 0x6e, 0x62, 0x38, 0x5a, 0x4e, 0x35, 0x44, 0x50, 0x61, 0x69, 0x32, 0x43,
317     0x75, 0x71, 0x43, 0x66, 0x49, 0x7a, 0x46, 0x50, 0x4c, 0x75, 0x37, 0x65, 0x6a, 0x61, 0x73, 0x31,
318     0x41, 0x74, 0x67, 0x33, 0x31, 0x6e, 0x38, 0x45, 0x35, 0x38, 0x55, 0x4d, 0x31, 0x51, 0x44, 0x45,
319     0x74, 0x71, 0x54, 0x0d, 0x0a, 0x58, 0x45, 0x47, 0x48, 0x61, 0x68, 0x6d, 0x74, 0x6e, 0x52, 0x30,
320     0x6e, 0x4f, 0x71, 0x61, 0x6e, 0x35, 0x63, 0x43, 0x6c, 0x54, 0x5a, 0x46, 0x6b, 0x61, 0x59, 0x46,
321     0x47, 0x79, 0x65, 0x54, 0x75, 0x76, 0x4f, 0x33, 0x69, 0x4e, 0x54, 0x47, 0x4d, 0x50, 0x69, 0x64,
322     0x4c, 0x48, 0x47, 0x51, 0x68, 0x55, 0x4b, 0x2f, 0x63, 0x4b, 0x6b, 0x67, 0x79, 0x52, 0x54, 0x68,
323     0x75, 0x38, 0x4f, 0x78, 0x6e, 0x0d, 0x0a, 0x2b, 0x67, 0x6d, 0x65, 0x33, 0x70, 0x66, 0x76, 0x49,
324     0x58, 0x74, 0x73, 0x61, 0x42, 0x4c, 0x71, 0x4e, 0x47, 0x69, 0x42, 0x38, 0x76, 0x69, 0x59, 0x2b,
325     0x6b, 0x48, 0x75, 0x72, 0x50, 0x64, 0x53, 0x4c, 0x36, 0x53, 0x72, 0x4a, 0x57, 0x65, 0x34, 0x76,
326     0x30, 0x39, 0x79, 0x62, 0x45, 0x6f, 0x74, 0x72, 0x30, 0x72, 0x34, 0x32, 0x30, 0x51, 0x74, 0x32,
327     0x33, 0x52, 0x69, 0x4a, 0x44, 0x69, 0x41, 0x0d, 0x0a, 0x54, 0x77, 0x48, 0x53, 0x78, 0x57, 0x6a,
328     0x64, 0x2f, 0x68, 0x64, 0x64, 0x43, 0x52, 0x75, 0x4b, 0x55, 0x4f, 0x6c, 0x36, 0x52, 0x56, 0x66,
329     0x4f, 0x4a, 0x56, 0x68, 0x4a, 0x75, 0x31, 0x4b, 0x65, 0x71, 0x6b, 0x70, 0x76, 0x78, 0x44, 0x37,
330     0x4d, 0x75, 0x6f, 0x39, 0x30, 0x6a, 0x41, 0x42, 0x4e, 0x44, 0x74, 0x4f, 0x4f, 0x43, 0x79, 0x5a,
331     0x61, 0x56, 0x6a, 0x7a, 0x36, 0x2f, 0x77, 0x75, 0x42, 0x0d, 0x0a, 0x53, 0x50, 0x64, 0x54, 0x34,
332     0x64, 0x2f, 0x4d, 0x49, 0x68, 0x51, 0x78, 0x49, 0x31, 0x76, 0x6a, 0x77, 0x48, 0x59, 0x51, 0x4d,
333     0x70, 0x54, 0x76, 0x4f, 0x38, 0x68, 0x34, 0x68, 0x46, 0x36, 0x45, 0x71, 0x73, 0x58, 0x31, 0x36,
334     0x70, 0x52, 0x41, 0x4a, 0x6b, 0x6e, 0x47, 0x6e, 0x63, 0x38, 0x4a, 0x59, 0x4d, 0x76, 0x62, 0x70,
335     0x56, 0x6e, 0x79, 0x63, 0x6e, 0x4a, 0x73, 0x43, 0x68, 0x65, 0x73, 0x0d, 0x0a, 0x46, 0x4c, 0x78,
336     0x6f, 0x6c, 0x77, 0x3d, 0x3d, 0x0d, 0x0a, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x45, 0x4e, 0x44, 0x20,
337     0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
338     // PEM encoded certificate
339     0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x43, 0x45, 0x52, 0x54, 0x49,
340     0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x44,
341     0x38, 0x44, 0x43, 0x43, 0x41, 0x74, 0x69, 0x67, 0x41, 0x77, 0x49, 0x42, 0x41, 0x67, 0x49, 0x44,
342     0x41, 0x6a, 0x71, 0x53, 0x4d, 0x41, 0x30, 0x47, 0x43, 0x53, 0x71, 0x47, 0x53, 0x49, 0x62, 0x33,
343     0x44, 0x51, 0x45, 0x42, 0x43, 0x77, 0x55, 0x41, 0x4d, 0x45, 0x49, 0x78, 0x43, 0x7a, 0x41, 0x4a,
344     0x42, 0x67, 0x4e, 0x56, 0x42, 0x41, 0x59, 0x54, 0x41, 0x6c, 0x56, 0x54, 0x0a, 0x4d, 0x52, 0x59,
345     0x77, 0x46, 0x41, 0x59, 0x44, 0x56, 0x51, 0x51, 0x4b, 0x45, 0x77, 0x31, 0x48, 0x5a, 0x57, 0x39,
346     0x55, 0x63, 0x6e, 0x56, 0x7a, 0x64, 0x43, 0x42, 0x4a, 0x62, 0x6d, 0x4d, 0x75, 0x4d, 0x52, 0x73,
347     0x77, 0x47, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x44, 0x45, 0x78, 0x4a, 0x48, 0x5a, 0x57, 0x39,
348     0x55, 0x63, 0x6e, 0x56, 0x7a, 0x64, 0x43, 0x42, 0x48, 0x62, 0x47, 0x39, 0x69, 0x0a, 0x59, 0x57,
349     0x77, 0x67, 0x51, 0x30, 0x45, 0x77, 0x48, 0x68, 0x63, 0x4e, 0x4d, 0x54, 0x55, 0x77, 0x4e, 0x44,
350     0x41, 0x78, 0x4d, 0x44, 0x41, 0x77, 0x4d, 0x44, 0x41, 0x77, 0x57, 0x68, 0x63, 0x4e, 0x4d, 0x54,
351     0x63, 0x78, 0x4d, 0x6a, 0x4d, 0x78, 0x4d, 0x6a, 0x4d, 0x31, 0x4f, 0x54, 0x55, 0x35, 0x57, 0x6a,
352     0x42, 0x4a, 0x4d, 0x51, 0x73, 0x77, 0x43, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x47, 0x0a, 0x45,
353     0x77, 0x4a, 0x56, 0x55, 0x7a, 0x45, 0x54, 0x4d, 0x42, 0x45, 0x47, 0x41, 0x31, 0x55, 0x45, 0x43,
354     0x68, 0x4d, 0x4b, 0x52, 0x32, 0x39, 0x76, 0x5a, 0x32, 0x78, 0x6c, 0x49, 0x45, 0x6c, 0x75, 0x59,
355     0x7a, 0x45, 0x6c, 0x4d, 0x43, 0x4d, 0x47, 0x41, 0x31, 0x55, 0x45, 0x41, 0x78, 0x4d, 0x63, 0x52,
356     0x32, 0x39, 0x76, 0x5a, 0x32, 0x78, 0x6c, 0x49, 0x45, 0x6c, 0x75, 0x64, 0x47, 0x56, 0x79, 0x0a,
357     0x62, 0x6d, 0x56, 0x30, 0x49, 0x45, 0x46, 0x31, 0x64, 0x47, 0x68, 0x76, 0x63, 0x6d, 0x6c, 0x30,
358     0x65, 0x53, 0x42, 0x48, 0x4d, 0x6a, 0x43, 0x43, 0x41, 0x53, 0x49, 0x77, 0x44, 0x51, 0x59, 0x4a,
359     0x4b, 0x6f, 0x5a, 0x49, 0x68, 0x76, 0x63, 0x4e, 0x41, 0x51, 0x45, 0x42, 0x42, 0x51, 0x41, 0x44,
360     0x67, 0x67, 0x45, 0x50, 0x41, 0x44, 0x43, 0x43, 0x41, 0x51, 0x6f, 0x43, 0x67, 0x67, 0x45, 0x42,
361     0x0a, 0x41, 0x4a, 0x77, 0x71, 0x42, 0x48, 0x64, 0x63, 0x32, 0x46, 0x43, 0x52, 0x4f, 0x67, 0x61,
362     0x6a, 0x67, 0x75, 0x44, 0x59, 0x55, 0x45, 0x69, 0x38, 0x69, 0x54, 0x2f, 0x78, 0x47, 0x58, 0x41,
363     0x61, 0x69, 0x45, 0x5a, 0x2b, 0x34, 0x49, 0x2f, 0x46, 0x38, 0x59, 0x6e, 0x4f, 0x49, 0x65, 0x35,
364     0x61, 0x2f, 0x6d, 0x45, 0x4e, 0x74, 0x7a, 0x4a, 0x45, 0x69, 0x61, 0x42, 0x30, 0x43, 0x31, 0x4e,
365     0x50, 0x0a, 0x56, 0x61, 0x54, 0x4f, 0x67, 0x6d, 0x4b, 0x56, 0x37, 0x75, 0x74, 0x5a, 0x58, 0x38,
366     0x62, 0x68, 0x42, 0x59, 0x41, 0x53, 0x78, 0x46, 0x36, 0x55, 0x50, 0x37, 0x78, 0x62, 0x53, 0x44,
367     0x6a, 0x30, 0x55, 0x2f, 0x63, 0x6b, 0x35, 0x76, 0x75, 0x52, 0x36, 0x52, 0x58, 0x45, 0x7a, 0x2f,
368     0x52, 0x54, 0x44, 0x66, 0x52, 0x4b, 0x2f, 0x4a, 0x39, 0x55, 0x33, 0x6e, 0x32, 0x2b, 0x6f, 0x47,
369     0x74, 0x76, 0x0a, 0x68, 0x38, 0x44, 0x51, 0x55, 0x42, 0x38, 0x6f, 0x4d, 0x41, 0x4e, 0x41, 0x32,
370     0x67, 0x68, 0x7a, 0x55, 0x57, 0x78, 0x2f, 0x2f, 0x7a, 0x6f, 0x38, 0x70, 0x7a, 0x63, 0x47, 0x6a,
371     0x72, 0x31, 0x4c, 0x45, 0x51, 0x54, 0x72, 0x66, 0x53, 0x54, 0x65, 0x35, 0x76, 0x6e, 0x38, 0x4d,
372     0x58, 0x48, 0x37, 0x6c, 0x4e, 0x56, 0x67, 0x38, 0x79, 0x35, 0x4b, 0x72, 0x30, 0x4c, 0x53, 0x79,
373     0x2b, 0x72, 0x45, 0x0a, 0x61, 0x68, 0x71, 0x79, 0x7a, 0x46, 0x50, 0x64, 0x46, 0x55, 0x75, 0x4c,
374     0x48, 0x38, 0x67, 0x5a, 0x59, 0x52, 0x2f, 0x4e, 0x6e, 0x61, 0x67, 0x2b, 0x59, 0x79, 0x75, 0x45,
375     0x4e, 0x57, 0x6c, 0x6c, 0x68, 0x4d, 0x67, 0x5a, 0x78, 0x55, 0x59, 0x69, 0x2b, 0x46, 0x4f, 0x56,
376     0x76, 0x75, 0x4f, 0x41, 0x53, 0x68, 0x44, 0x47, 0x4b, 0x75, 0x79, 0x36, 0x6c, 0x79, 0x41, 0x52,
377     0x78, 0x7a, 0x6d, 0x5a, 0x0a, 0x45, 0x41, 0x53, 0x67, 0x38, 0x47, 0x46, 0x36, 0x6c, 0x53, 0x57,
378     0x4d, 0x54, 0x6c, 0x4a, 0x31, 0x34, 0x72, 0x62, 0x74, 0x43, 0x4d, 0x6f, 0x55, 0x2f, 0x4d, 0x34,
379     0x69, 0x61, 0x72, 0x4e, 0x4f, 0x7a, 0x30, 0x59, 0x44, 0x6c, 0x35, 0x63, 0x44, 0x66, 0x73, 0x43,
380     0x78, 0x33, 0x6e, 0x75, 0x76, 0x52, 0x54, 0x50, 0x50, 0x75, 0x6a, 0x35, 0x78, 0x74, 0x39, 0x37,
381     0x30, 0x4a, 0x53, 0x58, 0x43, 0x0a, 0x44, 0x54, 0x57, 0x4a, 0x6e, 0x5a, 0x33, 0x37, 0x44, 0x68,
382     0x46, 0x35, 0x69, 0x52, 0x34, 0x33, 0x78, 0x61, 0x2b, 0x4f, 0x63, 0x6d, 0x6b, 0x43, 0x41, 0x77,
383     0x45, 0x41, 0x41, 0x61, 0x4f, 0x42, 0x35, 0x7a, 0x43, 0x42, 0x35, 0x44, 0x41, 0x66, 0x42, 0x67,
384     0x4e, 0x56, 0x48, 0x53, 0x4d, 0x45, 0x47, 0x44, 0x41, 0x57, 0x67, 0x42, 0x54, 0x41, 0x65, 0x70,
385     0x68, 0x6f, 0x6a, 0x59, 0x6e, 0x37, 0x0a, 0x71, 0x77, 0x56, 0x6b, 0x44, 0x42, 0x46, 0x39, 0x71,
386     0x6e, 0x31, 0x6c, 0x75, 0x4d, 0x72, 0x4d, 0x54, 0x6a, 0x41, 0x64, 0x42, 0x67, 0x4e, 0x56, 0x48,
387     0x51, 0x34, 0x45, 0x46, 0x67, 0x51, 0x55, 0x53, 0x74, 0x30, 0x47, 0x46, 0x68, 0x75, 0x38, 0x39,
388     0x6d, 0x69, 0x31, 0x64, 0x76, 0x57, 0x42, 0x74, 0x72, 0x74, 0x69, 0x47, 0x72, 0x70, 0x61, 0x67,
389     0x53, 0x38, 0x77, 0x44, 0x67, 0x59, 0x44, 0x0a, 0x56, 0x52, 0x30, 0x50, 0x41, 0x51, 0x48, 0x2f,
390     0x42, 0x41, 0x51, 0x44, 0x41, 0x67, 0x45, 0x47, 0x4d, 0x43, 0x34, 0x47, 0x43, 0x43, 0x73, 0x47,
391     0x41, 0x51, 0x55, 0x46, 0x42, 0x77, 0x45, 0x42, 0x42, 0x43, 0x49, 0x77, 0x49, 0x44, 0x41, 0x65,
392     0x42, 0x67, 0x67, 0x72, 0x42, 0x67, 0x45, 0x46, 0x42, 0x51, 0x63, 0x77, 0x41, 0x59, 0x59, 0x53,
393     0x61, 0x48, 0x52, 0x30, 0x63, 0x44, 0x6f, 0x76, 0x0a, 0x4c, 0x32, 0x63, 0x75, 0x63, 0x33, 0x6c,
394     0x74, 0x59, 0x32, 0x51, 0x75, 0x59, 0x32, 0x39, 0x74, 0x4d, 0x42, 0x49, 0x47, 0x41, 0x31, 0x55,
395     0x64, 0x45, 0x77, 0x45, 0x42, 0x2f, 0x77, 0x51, 0x49, 0x4d, 0x41, 0x59, 0x42, 0x41, 0x66, 0x38,
396     0x43, 0x41, 0x51, 0x41, 0x77, 0x4e, 0x51, 0x59, 0x44, 0x56, 0x52, 0x30, 0x66, 0x42, 0x43, 0x34,
397     0x77, 0x4c, 0x44, 0x41, 0x71, 0x6f, 0x43, 0x69, 0x67, 0x0a, 0x4a, 0x6f, 0x59, 0x6b, 0x61, 0x48,
398     0x52, 0x30, 0x63, 0x44, 0x6f, 0x76, 0x4c, 0x32, 0x63, 0x75, 0x63, 0x33, 0x6c, 0x74, 0x59, 0x32,
399     0x49, 0x75, 0x59, 0x32, 0x39, 0x74, 0x4c, 0x32, 0x4e, 0x79, 0x62, 0x48, 0x4d, 0x76, 0x5a, 0x33,
400     0x52, 0x6e, 0x62, 0x47, 0x39, 0x69, 0x59, 0x57, 0x77, 0x75, 0x59, 0x33, 0x4a, 0x73, 0x4d, 0x42,
401     0x63, 0x47, 0x41, 0x31, 0x55, 0x64, 0x49, 0x41, 0x51, 0x51, 0x0a, 0x4d, 0x41, 0x34, 0x77, 0x44,
402     0x41, 0x59, 0x4b, 0x4b, 0x77, 0x59, 0x42, 0x42, 0x41, 0x48, 0x57, 0x65, 0x51, 0x49, 0x46, 0x41,
403     0x54, 0x41, 0x4e, 0x42, 0x67, 0x6b, 0x71, 0x68, 0x6b, 0x69, 0x47, 0x39, 0x77, 0x30, 0x42, 0x41,
404     0x51, 0x73, 0x46, 0x41, 0x41, 0x4f, 0x43, 0x41, 0x51, 0x45, 0x41, 0x43, 0x45, 0x34, 0x45, 0x70,
405     0x34, 0x42, 0x2f, 0x45, 0x42, 0x5a, 0x44, 0x58, 0x67, 0x4b, 0x74, 0x0a, 0x31, 0x30, 0x4b, 0x41,
406     0x39, 0x4c, 0x43, 0x4f, 0x30, 0x71, 0x36, 0x7a, 0x36, 0x78, 0x46, 0x39, 0x6b, 0x49, 0x51, 0x59,
407     0x66, 0x65, 0x65, 0x51, 0x46, 0x66, 0x74, 0x4a, 0x66, 0x36, 0x69, 0x5a, 0x42, 0x5a, 0x47, 0x37,
408     0x65, 0x73, 0x6e, 0x57, 0x50, 0x44, 0x63, 0x59, 0x43, 0x5a, 0x71, 0x32, 0x78, 0x35, 0x49, 0x67,
409     0x42, 0x7a, 0x55, 0x7a, 0x43, 0x65, 0x51, 0x6f, 0x59, 0x33, 0x49, 0x4e, 0x0a, 0x74, 0x4f, 0x41,
410     0x79, 0x6e, 0x49, 0x65, 0x59, 0x78, 0x42, 0x74, 0x32, 0x69, 0x57, 0x66, 0x42, 0x55, 0x46, 0x69,
411     0x77, 0x45, 0x36, 0x6f, 0x54, 0x47, 0x68, 0x73, 0x79, 0x70, 0x62, 0x37, 0x71, 0x45, 0x5a, 0x56,
412     0x4d, 0x53, 0x47, 0x4e, 0x4a, 0x36, 0x5a, 0x6c, 0x64, 0x49, 0x44, 0x66, 0x4d, 0x2f, 0x69, 0x70,
413     0x70, 0x55, 0x52, 0x61, 0x56, 0x53, 0x36, 0x6e, 0x65, 0x53, 0x59, 0x4c, 0x41, 0x0a, 0x45, 0x48,
414     0x44, 0x30, 0x4c, 0x50, 0x50, 0x73, 0x76, 0x43, 0x51, 0x6b, 0x30, 0x45, 0x36, 0x73, 0x70, 0x64,
415     0x6c, 0x65, 0x48, 0x6d, 0x32, 0x53, 0x77, 0x61, 0x65, 0x73, 0x53, 0x44, 0x57, 0x42, 0x2b, 0x65,
416     0x58, 0x6b, 0x6e, 0x47, 0x56, 0x70, 0x7a, 0x59, 0x65, 0x6b, 0x51, 0x56, 0x41, 0x2f, 0x4c, 0x6c,
417     0x65, 0x6c, 0x6b, 0x56, 0x45, 0x53, 0x57, 0x41, 0x36, 0x4d, 0x43, 0x61, 0x47, 0x73, 0x0a, 0x65,
418     0x71, 0x51, 0x53, 0x70, 0x53, 0x66, 0x7a, 0x6d, 0x68, 0x43, 0x58, 0x66, 0x56, 0x55, 0x44, 0x42,
419     0x76, 0x64, 0x6d, 0x57, 0x46, 0x39, 0x66, 0x5a, 0x4f, 0x47, 0x72, 0x58, 0x57, 0x32, 0x6c, 0x4f,
420     0x55, 0x68, 0x31, 0x6d, 0x45, 0x77, 0x70, 0x57, 0x6a, 0x71, 0x4e, 0x30, 0x79, 0x76, 0x4b, 0x6e,
421     0x46, 0x55, 0x45, 0x76, 0x2f, 0x54, 0x6d, 0x46, 0x4e, 0x57, 0x41, 0x72, 0x43, 0x62, 0x74, 0x0a,
422     0x46, 0x34, 0x6d, 0x6d, 0x6b, 0x32, 0x78, 0x63, 0x70, 0x4d, 0x79, 0x34, 0x38, 0x47, 0x61, 0x4f,
423     0x5a, 0x4f, 0x4e, 0x39, 0x6d, 0x75, 0x49, 0x41, 0x73, 0x30, 0x6e, 0x48, 0x35, 0x41, 0x71, 0x71,
424     0x33, 0x56, 0x75, 0x44, 0x78, 0x33, 0x43, 0x51, 0x52, 0x6b, 0x36, 0x2b, 0x30, 0x4e, 0x74, 0x5a,
425     0x6c, 0x6d, 0x77, 0x75, 0x39, 0x52, 0x59, 0x32, 0x33, 0x6e, 0x48, 0x4d, 0x41, 0x63, 0x49, 0x53,
426     0x0a, 0x77, 0x53, 0x48, 0x47, 0x46, 0x67, 0x3d, 0x3d, 0x0a, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x45,
427     0x4e, 0x44, 0x20, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d,
428     0x2d, 0x2d, 0x2d,
429     // PEM encoded certificate
430     0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x43, 0x45, 0x52, 0x54, 0x49,
431     0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x43,
432     0x6e, 0x44, 0x43, 0x43, 0x41, 0x6a, 0x2b, 0x67, 0x41, 0x77, 0x49, 0x42, 0x41, 0x67, 0x49, 0x55,
433     0x44, 0x67, 0x45, 0x38, 0x4e, 0x50, 0x54, 0x4c, 0x46, 0x64, 0x6d, 0x68, 0x75, 0x72, 0x53, 0x69,
434     0x36, 0x33, 0x49, 0x31, 0x41, 0x77, 0x76, 0x37, 0x39, 0x49, 0x6b, 0x77, 0x44, 0x41, 0x59, 0x49,
435     0x4b, 0x6f, 0x5a, 0x49, 0x7a, 0x6a, 0x30, 0x45, 0x41, 0x77, 0x49, 0x46, 0x0a, 0x41, 0x44, 0x43,
436     0x42, 0x67, 0x7a, 0x45, 0x34, 0x4d, 0x44, 0x59, 0x47, 0x41, 0x31, 0x55, 0x45, 0x41, 0x78, 0x4d,
437     0x76, 0x55, 0x32, 0x46, 0x74, 0x63, 0x33, 0x56, 0x75, 0x5a, 0x79, 0x42, 0x46, 0x62, 0x47, 0x56,
438     0x6a, 0x64, 0x48, 0x4a, 0x76, 0x62, 0x6d, 0x6c, 0x6a, 0x63, 0x79, 0x42, 0x50, 0x51, 0x30, 0x59,
439     0x67, 0x54, 0x55, 0x4d, 0x67, 0x52, 0x47, 0x56, 0x32, 0x61, 0x57, 0x4e, 0x6c, 0x0a, 0x49, 0x46,
440     0x4e, 0x31, 0x59, 0x6b, 0x4e, 0x42, 0x49, 0x48, 0x59, 0x78, 0x49, 0x46, 0x52, 0x46, 0x55, 0x31,
441     0x51, 0x78, 0x48, 0x44, 0x41, 0x61, 0x42, 0x67, 0x4e, 0x56, 0x42, 0x41, 0x73, 0x54, 0x45, 0x30,
442     0x39, 0x44, 0x52, 0x69, 0x42, 0x4e, 0x51, 0x79, 0x42, 0x45, 0x5a, 0x58, 0x5a, 0x70, 0x59, 0x32,
443     0x55, 0x67, 0x55, 0x33, 0x56, 0x69, 0x51, 0x30, 0x45, 0x78, 0x48, 0x44, 0x41, 0x61, 0x0a, 0x42,
444     0x67, 0x4e, 0x56, 0x42, 0x41, 0x6f, 0x54, 0x45, 0x31, 0x4e, 0x68, 0x62, 0x58, 0x4e, 0x31, 0x62,
445     0x6d, 0x63, 0x67, 0x52, 0x57, 0x78, 0x6c, 0x59, 0x33, 0x52, 0x79, 0x62, 0x32, 0x35, 0x70, 0x59,
446     0x33, 0x4d, 0x78, 0x43, 0x7a, 0x41, 0x4a, 0x42, 0x67, 0x4e, 0x56, 0x42, 0x41, 0x59, 0x54, 0x41,
447     0x6b, 0x74, 0x53, 0x4d, 0x43, 0x41, 0x58, 0x44, 0x54, 0x45, 0x32, 0x4d, 0x54, 0x45, 0x79, 0x0a,
448     0x4e, 0x44, 0x41, 0x79, 0x4e, 0x44, 0x67, 0x78, 0x4d, 0x6c, 0x6f, 0x59, 0x44, 0x7a, 0x49, 0x77,
449     0x4e, 0x6a, 0x6b, 0x78, 0x4d, 0x6a, 0x4d, 0x78, 0x4d, 0x54, 0x51, 0x31, 0x4f, 0x54, 0x55, 0x35,
450     0x57, 0x6a, 0x43, 0x42, 0x6a, 0x54, 0x46, 0x49, 0x4d, 0x45, 0x59, 0x47, 0x41, 0x31, 0x55, 0x45,
451     0x41, 0x78, 0x4d, 0x2f, 0x54, 0x30, 0x4e, 0x47, 0x49, 0x45, 0x52, 0x6c, 0x64, 0x6d, 0x6c, 0x6a,
452     0x0a, 0x5a, 0x53, 0x42, 0x55, 0x52, 0x56, 0x4e, 0x55, 0x4f, 0x69, 0x42, 0x4f, 0x5a, 0x58, 0x52,
453     0x33, 0x62, 0x33, 0x4a, 0x72, 0x49, 0x43, 0x67, 0x77, 0x4e, 0x6a, 0x51, 0x79, 0x4e, 0x32, 0x45,
454     0x32, 0x4e, 0x53, 0x31, 0x69, 0x5a, 0x6a, 0x63, 0x30, 0x4c, 0x54, 0x51, 0x33, 0x4d, 0x7a, 0x63,
455     0x74, 0x4f, 0x54, 0x5a, 0x6d, 0x4d, 0x53, 0x30, 0x78, 0x59, 0x6d, 0x49, 0x78, 0x4f, 0x44, 0x5a,
456     0x6b, 0x0a, 0x4f, 0x47, 0x59, 0x33, 0x59, 0x6a, 0x4d, 0x70, 0x4d, 0x52, 0x59, 0x77, 0x46, 0x41,
457     0x59, 0x44, 0x56, 0x51, 0x51, 0x4c, 0x45, 0x77, 0x31, 0x50, 0x51, 0x30, 0x59, 0x67, 0x54, 0x55,
458     0x4d, 0x67, 0x52, 0x47, 0x56, 0x32, 0x61, 0x57, 0x4e, 0x6c, 0x4d, 0x52, 0x77, 0x77, 0x47, 0x67,
459     0x59, 0x44, 0x56, 0x51, 0x51, 0x4b, 0x45, 0x78, 0x4e, 0x54, 0x59, 0x57, 0x31, 0x7a, 0x64, 0x57,
460     0x35, 0x6e, 0x0a, 0x49, 0x45, 0x56, 0x73, 0x5a, 0x57, 0x4e, 0x30, 0x63, 0x6d, 0x39, 0x75, 0x61,
461     0x57, 0x4e, 0x7a, 0x4d, 0x51, 0x73, 0x77, 0x43, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x47, 0x45,
462     0x77, 0x4a, 0x4c, 0x55, 0x6a, 0x42, 0x5a, 0x4d, 0x42, 0x4d, 0x47, 0x42, 0x79, 0x71, 0x47, 0x53,
463     0x4d, 0x34, 0x39, 0x41, 0x67, 0x45, 0x47, 0x43, 0x43, 0x71, 0x47, 0x53, 0x4d, 0x34, 0x39, 0x41,
464     0x77, 0x45, 0x48, 0x0a, 0x41, 0x30, 0x49, 0x41, 0x42, 0x45, 0x45, 0x77, 0x51, 0x41, 0x52, 0x73,
465     0x62, 0x67, 0x43, 0x59, 0x2b, 0x43, 0x59, 0x6b, 0x49, 0x6a, 0x6b, 0x59, 0x6f, 0x47, 0x78, 0x6f,
466     0x52, 0x33, 0x75, 0x70, 0x33, 0x38, 0x59, 0x47, 0x54, 0x32, 0x63, 0x4b, 0x30, 0x31, 0x74, 0x6d,
467     0x32, 0x70, 0x38, 0x79, 0x4c, 0x4b, 0x4e, 0x73, 0x6d, 0x69, 0x53, 0x6f, 0x76, 0x46, 0x70, 0x4a,
468     0x32, 0x35, 0x63, 0x52, 0x0a, 0x74, 0x72, 0x57, 0x34, 0x41, 0x56, 0x7a, 0x76, 0x73, 0x64, 0x67,
469     0x62, 0x74, 0x72, 0x45, 0x62, 0x6b, 0x2b, 0x37, 0x73, 0x56, 0x61, 0x58, 0x50, 0x74, 0x78, 0x43,
470     0x6a, 0x67, 0x59, 0x41, 0x77, 0x66, 0x6a, 0x41, 0x4f, 0x42, 0x67, 0x4e, 0x56, 0x48, 0x51, 0x38,
471     0x42, 0x41, 0x66, 0x38, 0x45, 0x42, 0x41, 0x4d, 0x43, 0x41, 0x38, 0x67, 0x77, 0x4c, 0x67, 0x59,
472     0x44, 0x56, 0x52, 0x30, 0x66, 0x0a, 0x42, 0x43, 0x63, 0x77, 0x4a, 0x54, 0x41, 0x6a, 0x6f, 0x43,
473     0x47, 0x67, 0x48, 0x34, 0x59, 0x64, 0x61, 0x48, 0x52, 0x30, 0x63, 0x44, 0x6f, 0x76, 0x4c, 0x32,
474     0x4e, 0x68, 0x4c, 0x6e, 0x4e, 0x68, 0x62, 0x58, 0x4e, 0x31, 0x62, 0x6d, 0x64, 0x70, 0x62, 0x33,
475     0x52, 0x7a, 0x4c, 0x6d, 0x4e, 0x76, 0x62, 0x53, 0x39, 0x6a, 0x63, 0x6d, 0x77, 0x77, 0x50, 0x41,
476     0x59, 0x49, 0x4b, 0x77, 0x59, 0x42, 0x0a, 0x42, 0x51, 0x55, 0x48, 0x41, 0x51, 0x45, 0x45, 0x4d,
477     0x44, 0x41, 0x75, 0x4d, 0x43, 0x77, 0x47, 0x43, 0x43, 0x73, 0x47, 0x41, 0x51, 0x55, 0x46, 0x42,
478     0x7a, 0x41, 0x42, 0x68, 0x69, 0x42, 0x6f, 0x64, 0x48, 0x52, 0x77, 0x4f, 0x69, 0x38, 0x76, 0x62,
479     0x32, 0x4e, 0x7a, 0x63, 0x43, 0x31, 0x30, 0x5a, 0x58, 0x4e, 0x30, 0x4c, 0x6e, 0x4e, 0x68, 0x62,
480     0x58, 0x4e, 0x31, 0x62, 0x6d, 0x64, 0x70, 0x0a, 0x62, 0x33, 0x52, 0x7a, 0x4c, 0x6d, 0x4e, 0x76,
481     0x62, 0x54, 0x41, 0x4d, 0x42, 0x67, 0x67, 0x71, 0x68, 0x6b, 0x6a, 0x4f, 0x50, 0x51, 0x51, 0x44,
482     0x41, 0x67, 0x55, 0x41, 0x41, 0x30, 0x6b, 0x41, 0x4d, 0x45, 0x59, 0x43, 0x49, 0x51, 0x43, 0x33,
483     0x58, 0x30, 0x42, 0x61, 0x4f, 0x49, 0x6f, 0x63, 0x4b, 0x4f, 0x45, 0x65, 0x44, 0x46, 0x52, 0x6b,
484     0x63, 0x66, 0x30, 0x48, 0x76, 0x68, 0x68, 0x67, 0x0a, 0x73, 0x6c, 0x65, 0x49, 0x52, 0x32, 0x49,
485     0x62, 0x6d, 0x66, 0x34, 0x6e, 0x69, 0x52, 0x52, 0x55, 0x38, 0x41, 0x49, 0x68, 0x41, 0x4f, 0x4d,
486     0x44, 0x31, 0x77, 0x45, 0x62, 0x50, 0x67, 0x34, 0x70, 0x47, 0x77, 0x49, 0x79, 0x65, 0x77, 0x63,
487     0x61, 0x6b, 0x76, 0x72, 0x4e, 0x4b, 0x66, 0x44, 0x79, 0x2b, 0x4f, 0x4e, 0x43, 0x6e, 0x4e, 0x6e,
488     0x43, 0x59, 0x57, 0x4a, 0x37, 0x39, 0x35, 0x4b, 0x49, 0x0a, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x45,
489     0x4e, 0x44, 0x20, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d,
490     0x2d, 0x2d, 0x2d,
491     // PEM encoded certificate
492     0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x43, 0x45, 0x52, 0x54, 0x49,
493     0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x44,
494     0x38, 0x44, 0x43, 0x43, 0x41, 0x74, 0x69, 0x67, 0x41, 0x77, 0x49, 0x42, 0x41, 0x67, 0x49, 0x44,
495     0x41, 0x6a, 0x71, 0x53, 0x4d, 0x41, 0x30, 0x47, 0x43, 0x53, 0x71, 0x47, 0x53, 0x49, 0x62, 0x33,
496     0x44, 0x51, 0x45, 0x42, 0x43, 0x77, 0x55, 0x41, 0x4d, 0x45, 0x49, 0x78, 0x43, 0x7a, 0x41, 0x4a,
497     0x42, 0x67, 0x4e, 0x56, 0x42, 0x41, 0x59, 0x54, 0x41, 0x6c, 0x56, 0x54, 0x0a, 0x4d, 0x52, 0x59,
498     0x77, 0x46, 0x41, 0x59, 0x44, 0x56, 0x51, 0x51, 0x4b, 0x45, 0x77, 0x31, 0x48, 0x5a, 0x57, 0x39,
499     0x55, 0x63, 0x6e, 0x56, 0x7a, 0x64, 0x43, 0x42, 0x4a, 0x62, 0x6d, 0x4d, 0x75, 0x4d, 0x52, 0x73,
500     0x77, 0x47, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x44, 0x45, 0x78, 0x4a, 0x48, 0x5a, 0x57, 0x39,
501     0x55, 0x63, 0x6e, 0x56, 0x7a, 0x64, 0x43, 0x42, 0x48, 0x62, 0x47, 0x39, 0x69, 0x0a, 0x59, 0x57,
502     0x77, 0x67, 0x51, 0x30, 0x45, 0x77, 0x48, 0x68, 0x63, 0x4e, 0x4d, 0x54, 0x55, 0x77, 0x4e, 0x44,
503     0x41, 0x78, 0x4d, 0x44, 0x41, 0x77, 0x4d, 0x44, 0x41, 0x77, 0x57, 0x68, 0x63, 0x4e, 0x4d, 0x54,
504     0x63, 0x78, 0x4d, 0x6a, 0x4d, 0x78, 0x4d, 0x6a, 0x4d, 0x31, 0x4f, 0x54, 0x55, 0x35, 0x57, 0x6a,
505     0x42, 0x4a, 0x4d, 0x51, 0x73, 0x77, 0x43, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x47, 0x0a, 0x45,
506     0x77, 0x4a, 0x56, 0x55, 0x7a, 0x45, 0x54, 0x4d, 0x42, 0x45, 0x47, 0x41, 0x31, 0x55, 0x45, 0x43,
507     0x68, 0x4d, 0x4b, 0x52, 0x32, 0x39, 0x76, 0x5a, 0x32, 0x78, 0x6c, 0x49, 0x45, 0x6c, 0x75, 0x59,
508     0x7a, 0x45, 0x6c, 0x4d, 0x43, 0x4d, 0x47, 0x41, 0x31, 0x55, 0x45, 0x41, 0x78, 0x4d, 0x63, 0x52,
509     0x32, 0x39, 0x76, 0x5a, 0x32, 0x78, 0x6c, 0x49, 0x45, 0x6c, 0x75, 0x64, 0x47, 0x56, 0x79, 0x0a,
510     0x62, 0x6d, 0x56, 0x30, 0x49, 0x45, 0x46, 0x31, 0x64, 0x47, 0x68, 0x76, 0x63, 0x6d, 0x6c, 0x30,
511     0x65, 0x53, 0x42, 0x48, 0x4d, 0x6a, 0x43, 0x43, 0x41, 0x53, 0x49, 0x77, 0x44, 0x51, 0x59, 0x4a,
512     0x4b, 0x6f, 0x5a, 0x49, 0x68, 0x76, 0x63, 0x4e, 0x41, 0x51, 0x45, 0x42, 0x42, 0x51, 0x41, 0x44,
513     0x67, 0x67, 0x45, 0x50, 0x41, 0x44, 0x43, 0x43, 0x41, 0x51, 0x6f, 0x43, 0x67, 0x67, 0x45, 0x42,
514     0x0a, 0x41, 0x4a, 0x77, 0x71, 0x42, 0x48, 0x64, 0x63, 0x32, 0x46, 0x43, 0x52, 0x4f, 0x67, 0x61,
515     0x6a, 0x67, 0x75, 0x44, 0x59, 0x55, 0x45, 0x69, 0x38, 0x69, 0x54, 0x2f, 0x78, 0x47, 0x58, 0x41,
516     0x61, 0x69, 0x45, 0x5a, 0x2b, 0x34, 0x49, 0x2f, 0x46, 0x38, 0x59, 0x6e, 0x4f, 0x49, 0x65, 0x35,
517     0x61, 0x2f, 0x6d, 0x45, 0x4e, 0x74, 0x7a, 0x4a, 0x45, 0x69, 0x61, 0x42, 0x30, 0x43, 0x31, 0x4e,
518     0x50, 0x0a, 0x56, 0x61, 0x54, 0x4f, 0x67, 0x6d, 0x4b, 0x56, 0x37, 0x75, 0x74, 0x5a, 0x58, 0x38,
519     0x62, 0x68, 0x42, 0x59, 0x41, 0x53, 0x78, 0x46, 0x36, 0x55, 0x50, 0x37, 0x78, 0x62, 0x53, 0x44,
520     0x6a, 0x30, 0x55, 0x2f, 0x63, 0x6b, 0x35, 0x76, 0x75, 0x52, 0x36, 0x52, 0x58, 0x45, 0x7a, 0x2f,
521     0x52, 0x54, 0x44, 0x66, 0x52, 0x4b, 0x2f, 0x4a, 0x39, 0x55, 0x33, 0x6e, 0x32, 0x2b, 0x6f, 0x47,
522     0x74, 0x76, 0x0a, 0x68, 0x38, 0x44, 0x51, 0x55, 0x42, 0x38, 0x6f, 0x4d, 0x41, 0x4e, 0x41, 0x32,
523     0x67, 0x68, 0x7a, 0x55, 0x57, 0x78, 0x2f, 0x2f, 0x7a, 0x6f, 0x38, 0x70, 0x7a, 0x63, 0x47, 0x6a,
524     0x72, 0x31, 0x4c, 0x45, 0x51, 0x54, 0x72, 0x66, 0x53, 0x54, 0x65, 0x35, 0x76, 0x6e, 0x38, 0x4d,
525     0x58, 0x48, 0x37, 0x6c, 0x4e, 0x56, 0x67, 0x38, 0x79, 0x35, 0x4b, 0x72, 0x30, 0x4c, 0x53, 0x79,
526     0x2b, 0x72, 0x45, 0x0a, 0x61, 0x68, 0x71, 0x79, 0x7a, 0x46, 0x50, 0x64, 0x46, 0x55, 0x75, 0x4c,
527     0x48, 0x38, 0x67, 0x5a, 0x59, 0x52, 0x2f, 0x4e, 0x6e, 0x61, 0x67, 0x2b, 0x59, 0x79, 0x75, 0x45,
528     0x4e, 0x57, 0x6c, 0x6c, 0x68, 0x4d, 0x67, 0x5a, 0x78, 0x55, 0x59, 0x69, 0x2b, 0x46, 0x4f, 0x56,
529     0x76, 0x75, 0x4f, 0x41, 0x53, 0x68, 0x44, 0x47, 0x4b, 0x75, 0x79, 0x36, 0x6c, 0x79, 0x41, 0x52,
530     0x78, 0x7a, 0x6d, 0x5a, 0x0a, 0x45, 0x41, 0x53, 0x67, 0x38, 0x47, 0x46, 0x36, 0x6c, 0x53, 0x57,
531     0x4d, 0x54, 0x6c, 0x4a, 0x31, 0x34, 0x72, 0x62, 0x74, 0x43, 0x4d, 0x6f, 0x55, 0x2f, 0x4d, 0x34,
532     0x69, 0x61, 0x72, 0x4e, 0x4f, 0x7a, 0x30, 0x59, 0x44, 0x6c, 0x35, 0x63, 0x44, 0x66, 0x73, 0x43,
533     0x78, 0x33, 0x6e, 0x75, 0x76, 0x52, 0x54, 0x50, 0x50, 0x75, 0x6a, 0x35, 0x78, 0x74, 0x39, 0x37,
534     0x30, 0x4a, 0x53, 0x58, 0x43, 0x0a, 0x44, 0x54, 0x57, 0x4a, 0x6e, 0x5a, 0x33, 0x37, 0x44, 0x68,
535     0x46, 0x35, 0x69, 0x52, 0x34, 0x33, 0x78, 0x61, 0x2b, 0x4f, 0x63, 0x6d, 0x6b, 0x43, 0x41, 0x77,
536     0x45, 0x41, 0x41, 0x61, 0x4f, 0x42, 0x35, 0x7a, 0x43, 0x42, 0x35, 0x44, 0x41, 0x66, 0x42, 0x67,
537     0x4e, 0x56, 0x48, 0x53, 0x4d, 0x45, 0x47, 0x44, 0x41, 0x57, 0x67, 0x42, 0x54, 0x41, 0x65, 0x70,
538     0x68, 0x6f, 0x6a, 0x59, 0x6e, 0x37, 0x0a, 0x71, 0x77, 0x56, 0x6b, 0x44, 0x42, 0x46, 0x39, 0x71,
539     0x6e, 0x31, 0x6c, 0x75, 0x4d, 0x72, 0x4d, 0x54, 0x6a, 0x41, 0x64, 0x42, 0x67, 0x4e, 0x56, 0x48,
540     0x51, 0x34, 0x45, 0x46, 0x67, 0x51, 0x55, 0x53, 0x74, 0x30, 0x47, 0x46, 0x68, 0x75, 0x38, 0x39,
541     0x6d, 0x69, 0x31, 0x64, 0x76, 0x57, 0x42, 0x74, 0x72, 0x74, 0x69, 0x47, 0x72, 0x70, 0x61, 0x67,
542     0x53, 0x38, 0x77, 0x44, 0x67, 0x59, 0x44, 0x0a, 0x56, 0x52, 0x30, 0x50, 0x41, 0x51, 0x48, 0x2f,
543     0x42, 0x41, 0x51, 0x44, 0x41, 0x67, 0x45, 0x47, 0x4d, 0x43, 0x34, 0x47, 0x43, 0x43, 0x73, 0x47,
544     0x41, 0x51, 0x55, 0x46, 0x42, 0x77, 0x45, 0x42, 0x42, 0x43, 0x49, 0x77, 0x49, 0x44, 0x41, 0x65,
545     0x42, 0x67, 0x67, 0x72, 0x42, 0x67, 0x45, 0x46, 0x42, 0x51, 0x63, 0x77, 0x41, 0x59, 0x59, 0x53,
546     0x61, 0x48, 0x52, 0x30, 0x63, 0x44, 0x6f, 0x76, 0x0a, 0x4c, 0x32, 0x63, 0x75, 0x63, 0x33, 0x6c,
547     0x74, 0x59, 0x32, 0x51, 0x75, 0x59, 0x32, 0x39, 0x74, 0x4d, 0x42, 0x49, 0x47, 0x41, 0x31, 0x55,
548     0x64, 0x45, 0x77, 0x45, 0x42, 0x2f, 0x77, 0x51, 0x49, 0x4d, 0x41, 0x59, 0x42, 0x41, 0x66, 0x38,
549     0x43, 0x41, 0x51, 0x41, 0x77, 0x4e, 0x51, 0x59, 0x44, 0x56, 0x52, 0x30, 0x66, 0x42, 0x43, 0x34,
550     0x77, 0x4c, 0x44, 0x41, 0x71, 0x6f, 0x43, 0x69, 0x67, 0x0a, 0x4a, 0x6f, 0x59, 0x6b, 0x61, 0x48,
551     0x52, 0x30, 0x63, 0x44, 0x6f, 0x76, 0x4c, 0x32, 0x63, 0x75, 0x63, 0x33, 0x6c, 0x74, 0x59, 0x32,
552     0x49, 0x75, 0x59, 0x32, 0x39, 0x74, 0x4c, 0x32, 0x4e, 0x79, 0x62, 0x48, 0x4d, 0x76, 0x5a, 0x33,
553     0x52, 0x6e, 0x62, 0x47, 0x39, 0x69, 0x59, 0x57, 0x77, 0x75, 0x59, 0x33, 0x4a, 0x73, 0x4d, 0x42,
554     0x63, 0x47, 0x41, 0x31, 0x55, 0x64, 0x49, 0x41, 0x51, 0x51, 0x0a, 0x4d, 0x41, 0x34, 0x77, 0x44,
555     0x41, 0x59, 0x4b, 0x4b, 0x77, 0x59, 0x42, 0x42, 0x41, 0x48, 0x57, 0x65, 0x51, 0x49, 0x46, 0x41,
556     0x54, 0x41, 0x4e, 0x42, 0x67, 0x6b, 0x71, 0x68, 0x6b, 0x69, 0x47, 0x39, 0x77, 0x30, 0x42, 0x41,
557     0x51, 0x73, 0x46, 0x41, 0x41, 0x4f, 0x43, 0x41, 0x51, 0x45, 0x41, 0x43, 0x45, 0x34, 0x45, 0x70,
558     0x34, 0x42, 0x2f, 0x45, 0x42, 0x5a, 0x44, 0x58, 0x67, 0x4b, 0x74, 0x0a, 0x31, 0x30, 0x4b, 0x41,
559     0x39, 0x4c, 0x43, 0x4f, 0x30, 0x71, 0x36, 0x7a, 0x36, 0x78, 0x46, 0x39, 0x6b, 0x49, 0x51, 0x59,
560     0x66, 0x65, 0x65, 0x51, 0x46, 0x66, 0x74, 0x4a, 0x66, 0x36, 0x69, 0x5a, 0x42, 0x5a, 0x47, 0x37,
561     0x65, 0x73, 0x6e, 0x57, 0x50, 0x44, 0x63, 0x59, 0x43, 0x5a, 0x71, 0x32, 0x78, 0x35, 0x49, 0x67,
562     0x42, 0x7a, 0x55, 0x7a, 0x43, 0x65, 0x51, 0x6f, 0x59, 0x33, 0x49, 0x4e, 0x0a, 0x74, 0x4f, 0x41,
563     0x79, 0x6e, 0x49, 0x65, 0x59, 0x78, 0x42, 0x74, 0x32, 0x69, 0x57, 0x66, 0x42, 0x55, 0x46, 0x69,
564     0x77, 0x45, 0x36, 0x6f, 0x54, 0x47, 0x68, 0x73, 0x79, 0x70, 0x62, 0x37, 0x71, 0x45, 0x5a, 0x56,
565     0x4d, 0x53, 0x47, 0x4e, 0x4a, 0x36, 0x5a, 0x6c, 0x64, 0x49, 0x44, 0x66, 0x4d, 0x2f, 0x69, 0x70,
566     0x70, 0x55, 0x52, 0x61, 0x56, 0x53, 0x36, 0x6e, 0x65, 0x53, 0x59, 0x4c, 0x41, 0x0a, 0x45, 0x48,
567     0x44, 0x30, 0x4c, 0x50, 0x50, 0x73, 0x76, 0x43, 0x51, 0x6b, 0x30, 0x45, 0x36, 0x73, 0x70, 0x64,
568     0x6c, 0x65, 0x48, 0x6d, 0x32, 0x53, 0x77, 0x61, 0x65, 0x73, 0x53, 0x44, 0x57, 0x42, 0x2b, 0x65,
569     0x58, 0x6b, 0x6e, 0x47, 0x56, 0x70, 0x7a, 0x59, 0x65, 0x6b, 0x51, 0x56, 0x41, 0x2f, 0x4c, 0x6c,
570     0x65, 0x6c, 0x6b, 0x56, 0x45, 0x53, 0x57, 0x41, 0x36, 0x4d, 0x43, 0x61, 0x47, 0x73, 0x0a, 0x65,
571     0x71, 0x51, 0x53, 0x70, 0x53, 0x66, 0x7a, 0x6d, 0x68, 0x43, 0x58, 0x66, 0x56, 0x55, 0x44, 0x42,
572     0x76, 0x64, 0x6d, 0x57, 0x46, 0x39, 0x66, 0x5a, 0x4f, 0x47, 0x72, 0x58, 0x57, 0x32, 0x6c, 0x4f,
573     0x55, 0x68, 0x31, 0x6d, 0x45, 0x77, 0x70, 0x57, 0x6a, 0x71, 0x4e, 0x30, 0x79, 0x76, 0x4b, 0x6e,
574     0x46, 0x55, 0x45, 0x76, 0x2f, 0x54, 0x6d, 0x46, 0x4e, 0x57, 0x41, 0x72, 0x43, 0x62, 0x74, 0x0a,
575     0x46, 0x34, 0x6d, 0x6d, 0x6b, 0x32, 0x78, 0x63, 0x70, 0x4d, 0x79, 0x34, 0x38, 0x47, 0x61, 0x4f,
576     0x5a, 0x4f, 0x4e, 0x39, 0x6d, 0x75, 0x49, 0x41, 0x73, 0x30, 0x6e, 0x48, 0x35, 0x41, 0x71, 0x71,
577     0x33, 0x56, 0x75, 0x44, 0x78, 0x33, 0x43, 0x51, 0x52, 0x6b, 0x36, 0x2b, 0x30, 0x4e, 0x74, 0x5a,
578     0x6c, 0x6d, 0x77, 0x75, 0x39, 0x52, 0x59, 0x32, 0x33, 0x6e, 0x48, 0x4d, 0x41, 0x63, 0x49, 0x53,
579     0x0a, 0x77, 0x53, 0x48, 0x47, 0x46, 0x67, 0x3d, 0x3d, 0x0a, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x45,
580     0x4e, 0x44, 0x20, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d,
581     0x2d, 0x2d, 0x2d,
582     // PEM encoded certificate
583     0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x43, 0x45, 0x52, 0x54, 0x49,
584     0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x43,
585     0x6e, 0x44, 0x43, 0x43, 0x41, 0x6a, 0x2b, 0x67, 0x41, 0x77, 0x49, 0x42, 0x41, 0x67, 0x49, 0x55,
586     0x44, 0x67, 0x45, 0x38, 0x4e, 0x50, 0x54, 0x4c, 0x46, 0x64, 0x6d, 0x68, 0x75, 0x72, 0x53, 0x69,
587     0x36, 0x33, 0x49, 0x31, 0x41, 0x77, 0x76, 0x37, 0x39, 0x49, 0x6b, 0x77, 0x44, 0x41, 0x59, 0x49,
588     0x4b, 0x6f, 0x5a, 0x49, 0x7a, 0x6a, 0x30, 0x45, 0x41, 0x77, 0x49, 0x46, 0x0a, 0x41, 0x44, 0x43,
589     0x42, 0x67, 0x7a, 0x45, 0x34, 0x4d, 0x44, 0x59, 0x47, 0x41, 0x31, 0x55, 0x45, 0x41, 0x78, 0x4d,
590     0x76, 0x55, 0x32, 0x46, 0x74, 0x63, 0x33, 0x56, 0x75, 0x5a, 0x79, 0x42, 0x46, 0x62, 0x47, 0x56,
591     0x6a, 0x64, 0x48, 0x4a, 0x76, 0x62, 0x6d, 0x6c, 0x6a, 0x63, 0x79, 0x42, 0x50, 0x51, 0x30, 0x59,
592     0x67, 0x54, 0x55, 0x4d, 0x67, 0x52, 0x47, 0x56, 0x32, 0x61, 0x57, 0x4e, 0x6c, 0x0a, 0x49, 0x46,
593     0x4e, 0x31, 0x59, 0x6b, 0x4e, 0x42, 0x49, 0x48, 0x59, 0x78, 0x49, 0x46, 0x52, 0x46, 0x55, 0x31,
594     0x51, 0x78, 0x48, 0x44, 0x41, 0x61, 0x42, 0x67, 0x4e, 0x56, 0x42, 0x41, 0x73, 0x54, 0x45, 0x30,
595     0x39, 0x44, 0x52, 0x69, 0x42, 0x4e, 0x51, 0x79, 0x42, 0x45, 0x5a, 0x58, 0x5a, 0x70, 0x59, 0x32,
596     0x55, 0x67, 0x55, 0x33, 0x56, 0x69, 0x51, 0x30, 0x45, 0x78, 0x48, 0x44, 0x41, 0x61, 0x0a, 0x42,
597     0x67, 0x4e, 0x56, 0x42, 0x41, 0x6f, 0x54, 0x45, 0x31, 0x4e, 0x68, 0x62, 0x58, 0x4e, 0x31, 0x62,
598     0x6d, 0x63, 0x67, 0x52, 0x57, 0x78, 0x6c, 0x59, 0x33, 0x52, 0x79, 0x62, 0x32, 0x35, 0x70, 0x59,
599     0x33, 0x4d, 0x78, 0x43, 0x7a, 0x41, 0x4a, 0x42, 0x67, 0x4e, 0x56, 0x42, 0x41, 0x59, 0x54, 0x41,
600     0x6b, 0x74, 0x53, 0x4d, 0x43, 0x41, 0x58, 0x44, 0x54, 0x45, 0x32, 0x4d, 0x54, 0x45, 0x79, 0x0a,
601     0x4e, 0x44, 0x41, 0x79, 0x4e, 0x44, 0x67, 0x78, 0x4d, 0x6c, 0x6f, 0x59, 0x44, 0x7a, 0x49, 0x77,
602     0x4e, 0x6a, 0x6b, 0x78, 0x4d, 0x6a, 0x4d, 0x78, 0x4d, 0x54, 0x51, 0x31, 0x4f, 0x54, 0x55, 0x35,
603     0x57, 0x6a, 0x43, 0x42, 0x6a, 0x54, 0x46, 0x49, 0x4d, 0x45, 0x59, 0x47, 0x41, 0x31, 0x55, 0x45,
604     0x41, 0x78, 0x4d, 0x2f, 0x54, 0x30, 0x4e, 0x47, 0x49, 0x45, 0x52, 0x6c, 0x64, 0x6d, 0x6c, 0x6a,
605     0x0a, 0x5a, 0x53, 0x42, 0x55, 0x52, 0x56, 0x4e, 0x55, 0x4f, 0x69, 0x42, 0x4f, 0x5a, 0x58, 0x52,
606     0x33, 0x62, 0x33, 0x4a, 0x72, 0x49, 0x43, 0x67, 0x77, 0x4e, 0x6a, 0x51, 0x79, 0x4e, 0x32, 0x45,
607     0x32, 0x4e, 0x53, 0x31, 0x69, 0x5a, 0x6a, 0x63, 0x30, 0x4c, 0x54, 0x51, 0x33, 0x4d, 0x7a, 0x63,
608     0x74, 0x4f, 0x54, 0x5a, 0x6d, 0x4d, 0x53, 0x30, 0x78, 0x59, 0x6d, 0x49, 0x78, 0x4f, 0x44, 0x5a,
609     0x6b, 0x0a, 0x4f, 0x47, 0x59, 0x33, 0x59, 0x6a, 0x4d, 0x70, 0x4d, 0x52, 0x59, 0x77, 0x46, 0x41,
610     0x59, 0x44, 0x56, 0x51, 0x51, 0x4c, 0x45, 0x77, 0x31, 0x50, 0x51, 0x30, 0x59, 0x67, 0x54, 0x55,
611     0x4d, 0x67, 0x52, 0x47, 0x56, 0x32, 0x61, 0x57, 0x4e, 0x6c, 0x4d, 0x52, 0x77, 0x77, 0x47, 0x67,
612     0x59, 0x44, 0x56, 0x51, 0x51, 0x4b, 0x45, 0x78, 0x4e, 0x54, 0x59, 0x57, 0x31, 0x7a, 0x64, 0x57,
613     0x35, 0x6e, 0x0a, 0x49, 0x45, 0x56, 0x73, 0x5a, 0x57, 0x4e, 0x30, 0x63, 0x6d, 0x39, 0x75, 0x61,
614     0x57, 0x4e, 0x7a, 0x4d, 0x51, 0x73, 0x77, 0x43, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x47, 0x45,
615     0x77, 0x4a, 0x4c, 0x55, 0x6a, 0x42, 0x5a, 0x4d, 0x42, 0x4d, 0x47, 0x42, 0x79, 0x71, 0x47, 0x53,
616     0x4d, 0x34, 0x39, 0x41, 0x67, 0x45, 0x47, 0x43, 0x43, 0x71, 0x47, 0x53, 0x4d, 0x34, 0x39, 0x41,
617     0x77, 0x45, 0x48, 0x0a, 0x41, 0x30, 0x49, 0x41, 0x42, 0x45, 0x45, 0x77, 0x51, 0x41, 0x52, 0x73,
618     0x62, 0x67, 0x43, 0x59, 0x2b, 0x43, 0x59, 0x6b, 0x49, 0x6a, 0x6b, 0x59, 0x6f, 0x47, 0x78, 0x6f,
619     0x52, 0x33, 0x75, 0x70, 0x33, 0x38, 0x59, 0x47, 0x54, 0x32, 0x63, 0x4b, 0x30, 0x31, 0x74, 0x6d,
620     0x32, 0x70, 0x38, 0x79, 0x4c, 0x4b, 0x4e, 0x73, 0x6d, 0x69, 0x53, 0x6f, 0x76, 0x46, 0x70, 0x4a,
621     0x32, 0x35, 0x63, 0x52, 0x0a, 0x74, 0x72, 0x57, 0x34, 0x41, 0x56, 0x7a, 0x76, 0x73, 0x64, 0x67,
622     0x62, 0x74, 0x72, 0x45, 0x62, 0x6b, 0x2b, 0x37, 0x73, 0x56, 0x61, 0x58, 0x50, 0x74, 0x78, 0x43,
623     0x6a, 0x67, 0x59, 0x41, 0x77, 0x66, 0x6a, 0x41, 0x4f, 0x42, 0x67, 0x4e, 0x56, 0x48, 0x51, 0x38,
624     0x42, 0x41, 0x66, 0x38, 0x45, 0x42, 0x41, 0x4d, 0x43, 0x41, 0x38, 0x67, 0x77, 0x4c, 0x67, 0x59,
625     0x44, 0x56, 0x52, 0x30, 0x66, 0x0a, 0x42, 0x43, 0x63, 0x77, 0x4a, 0x54, 0x41, 0x6a, 0x6f, 0x43,
626     0x47, 0x67, 0x48, 0x34, 0x59, 0x64, 0x61, 0x48, 0x52, 0x30, 0x63, 0x44, 0x6f, 0x76, 0x4c, 0x32,
627     0x4e, 0x68, 0x4c, 0x6e, 0x4e, 0x68, 0x62, 0x58, 0x4e, 0x31, 0x62, 0x6d, 0x64, 0x70, 0x62, 0x33,
628     0x52, 0x7a, 0x4c, 0x6d, 0x4e, 0x76, 0x62, 0x53, 0x39, 0x6a, 0x63, 0x6d, 0x77, 0x77, 0x50, 0x41,
629     0x59, 0x49, 0x4b, 0x77, 0x59, 0x42, 0x0a, 0x42, 0x51, 0x55, 0x48, 0x41, 0x51, 0x45, 0x45, 0x4d,
630     0x44, 0x41, 0x75, 0x4d, 0x43, 0x77, 0x47, 0x43, 0x43, 0x73, 0x47, 0x41, 0x51, 0x55, 0x46, 0x42,
631     0x7a, 0x41, 0x42, 0x68, 0x69, 0x42, 0x6f, 0x64, 0x48, 0x52, 0x77, 0x4f, 0x69, 0x38, 0x76, 0x62,
632     0x32, 0x4e, 0x7a, 0x63, 0x43, 0x31, 0x30, 0x5a, 0x58, 0x4e, 0x30, 0x4c, 0x6e, 0x4e, 0x68, 0x62,
633     0x58, 0x4e, 0x31, 0x62, 0x6d, 0x64, 0x70, 0x0a, 0x62, 0x33, 0x52, 0x7a, 0x4c, 0x6d, 0x4e, 0x76,
634     0x62, 0x54, 0x41, 0x4d, 0x42, 0x67, 0x67, 0x71, 0x68, 0x6b, 0x6a, 0x4f, 0x50, 0x51, 0x51, 0x44,
635     0x41, 0x67, 0x55, 0x41, 0x41, 0x30, 0x6b, 0x41, 0x4d, 0x45, 0x59, 0x43, 0x49, 0x51, 0x43, 0x33,
636     0x58, 0x30, 0x42, 0x61, 0x4f, 0x49, 0x6f, 0x63, 0x4b, 0x4f, 0x45, 0x65, 0x44, 0x46, 0x52, 0x6b,
637     0x63, 0x66, 0x30, 0x48, 0x76, 0x68, 0x68, 0x67, 0x0a, 0x73, 0x6c, 0x65, 0x49, 0x52, 0x32, 0x49,
638     0x62, 0x6d, 0x66, 0x34, 0x6e, 0x69, 0x52, 0x52, 0x55, 0x38, 0x41, 0x49, 0x68, 0x41, 0x4f, 0x4d,
639     0x44, 0x31, 0x77, 0x45, 0x62, 0x50, 0x67, 0x34, 0x70, 0x47, 0x77, 0x49, 0x79, 0x65, 0x77, 0x63,
640     0x61, 0x6b, 0x76, 0x72, 0x4e, 0x4b, 0x66, 0x44, 0x79, 0x2b, 0x4f, 0x4e, 0x43, 0x6e, 0x4e, 0x6e,
641     0x43, 0x59, 0x57, 0x4a, 0x37, 0x39, 0x35, 0x4b, 0x49, 0x0a, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x45,
642     0x4e, 0x44, 0x20, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d,
643     0x2d, 0x2d, 0x2d,
644     // NULL terminator
645     0x00
646 };
647 int certChainLen = sizeof(certChain);
648
649 unsigned char serverCert[] =
650     "-----BEGIN CERTIFICATE-----\n"
651     "MIICOTCCAd8CAQEwCgYIKoZIzj0EAwIwfDELMAkGA1UEBhMCVVMxEjAQBgNVBAgM\n"
652     "CVNvbWVzdGF0ZTERMA8GA1UEBwwIU29tZWNpdHkxCzAJBgNVBAoMAkJCMRYwFAYD\n"
653     "VQQLDA1TZXF1cml0eSBQYXJ0MQswCQYDVQQDDAJvYjEUMBIGCSqGSIb3DQEJARYF\n"
654     "b2JAYmIwHhcNMTYwODE1MTMxMTE3WhcNMTkwNTEyMTMxMTE3WjCB1DELMAkGA1UE\n"
655     "BhMCVUExDDAKBgNVBAgMA0FzZDEPMA0GA1UEBwwGR290aGFtMQswCQYDVQQKDAJa\n"
656     "WjERMA8GA1UECwwIQmVhbVRlYW0xHDAaBgkqhkiG9w0BCQEWDXJhaWxAbWFpbC5j\n"
657     "b20xMjAwBgNVBAMMKXV1aWQ6MzIzMjMyMzItMzIzMi0zMjMyLTMyMzItMzIzMjMy\n"
658     "MzIzMjMyMTQwMgYDVR0RDCt1c2VyaWQ6Njc2NzY3NjctNjc2Ny02NzY3LTY3Njct\n"
659     "Njc2NzY3Njc2NzY3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE9xNcc3LOEOUJ\n"
660     "l5r48nCmPYn1xeRE4kq2YagSjbTcK0eEYAwlZung5awivxXccbGITxa/wnc3dj/g\n"
661     "Z8YdI/58izAKBggqhkjOPQQDAgNIADBFAiBHzEGKJ8fQqrSrhb8JTQbXfg05+Tah\n"
662     "PZYj4iRkmGMhugIhAOWPf/GmggNqGHpU5w4ld9hG+paKfhTEyyEyPonZuow/\n"
663     "-----END CERTIFICATE-----\n";
664 int serverCertLen = sizeof(serverCert);
665
666 unsigned char serverPrivateKey[] = {
667     0x30, 0x77, 0x02, 0x01, 0x01, 0x04, 0x20, 0x02, 0x51, 0xb5, 0x97, 0xb9, 0xe9, 0xd8, 0x8d, 0x66,
668     0x2b, 0x8a, 0xb3, 0x9c, 0x6a, 0xd2, 0xca, 0x18, 0x21, 0xb9, 0x87, 0x3d, 0xf5, 0x8e, 0xa2, 0x8d,
669     0x38, 0xf6, 0xb7, 0xd2, 0x76, 0x74, 0x99, 0xa0, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
670     0x03, 0x01, 0x07, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0xf7, 0x13, 0x5c, 0x73, 0x72, 0xce, 0x10,
671     0xe5, 0x09, 0x97, 0x9a, 0xf8, 0xf2, 0x70, 0xa6, 0x3d, 0x89, 0xf5, 0xc5, 0xe4, 0x44, 0xe2, 0x4a,
672     0xb6, 0x61, 0xa8, 0x12, 0x8d, 0xb4, 0xdc, 0x2b, 0x47, 0x84, 0x60, 0x0c, 0x25, 0x66, 0xe9, 0xe0,
673     0xe5, 0xac, 0x22, 0xbf, 0x15, 0xdc, 0x71, 0xb1, 0x88, 0x4f, 0x16, 0xbf, 0xc2, 0x77, 0x37, 0x76,
674     0x3f, 0xe0, 0x67, 0xc6, 0x1d, 0x23, 0xfe, 0x7c, 0x8b
675 };
676
677 int serverPrivateKeyLen = sizeof(serverPrivateKey);
678
679 unsigned char caCert[] = 
680     "-----BEGIN CERTIFICATE-----\n"
681     "MIICPjCCAeWgAwIBAgIJAIenaAF86fjwMAoGCCqGSM49BAMCMHwxCzAJBgNVBAYT\n"
682     "AlVTMRIwEAYDVQQIDAlTb21lc3RhdGUxETAPBgNVBAcMCFNvbWVjaXR5MQswCQYD\n"
683     "VQQKDAJCQjEWMBQGA1UECwwNU2VxdXJpdHkgUGFydDELMAkGA1UEAwwCb2IxFDAS\n"
684     "BgkqhkiG9w0BCQEWBW9iQGJiMB4XDTE2MDcyNTExMTYxMVoXDTE5MDUxNTExMTYx\n"
685     "MVowfDELMAkGA1UEBhMCVVMxEjAQBgNVBAgMCVNvbWVzdGF0ZTERMA8GA1UEBwwI\n"
686     "U29tZWNpdHkxCzAJBgNVBAoMAkJCMRYwFAYDVQQLDA1TZXF1cml0eSBQYXJ0MQsw\n"
687     "CQYDVQQDDAJvYjEUMBIGCSqGSIb3DQEJARYFb2JAYmIwWTATBgcqhkjOPQIBBggq\n"
688     "hkjOPQMBBwNCAAQuz8P6LgQRYjRjb9+2Z/taUIwVc8nBVzqe+PSoDBrpkVGdAyZI\n"
689     "qkaEEgYt/Ga+Qe39zTKjmzTyqpUfjl1Jd4DCo1AwTjAdBgNVHQ4EFgQUHoHDYv+M\n"
690     "WpiQrCzDZbk/jwRV+nwwHwYDVR0jBBgwFoAUHoHDYv+MWpiQrCzDZbk/jwRV+nww\n"
691     "DAYDVR0TBAUwAwEB/zAKBggqhkjOPQQDAgNHADBEAiAcoVWoBLxbAKisL+a3PHzz\n"
692     "fpPO4N9uNuQ2IMs2nBM7xAIgfxgTfRuM41vZrHSMwOm/G0hvtmpFA6ZdTWX3lqAI\n"
693     "g3w=\n"
694     "-----END CERTIFICATE-----\n";
695 int caCertLen = sizeof(caCert);
696
697 unsigned char control_server_message_ECDHE_ECDSA_WITH_AES_128_CCM[] = {
698     0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x20, 0x32, 0x30, 0x30, 0x20, 0x4f, 0x4b, 0x0d,
699     0x0a, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x54, 0x79, 0x70, 0x65, 0x3a, 0x20, 0x74,
700     0x65, 0x78, 0x74, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x0d, 0x0a, 0x0d, 0x0a, 0x3c, 0x68, 0x32, 0x3e,
701     0x6d, 0x62, 0x65, 0x64, 0x20, 0x54, 0x4c, 0x53, 0x20, 0x54, 0x65, 0x73, 0x74, 0x20, 0x53, 0x65,
702     0x72, 0x76, 0x65, 0x72, 0x3c, 0x2f, 0x68, 0x32, 0x3e, 0x0d, 0x0a, 0x54, 0x45, 0x53, 0x54, 0x20,
703     0x4d, 0x45, 0x53, 0x53, 0x41, 0x47, 0x45, 0x0d, 0x0a, 0x3c, 0x70, 0x3e, 0x53, 0x75, 0x63, 0x63,
704     0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f,
705     0x6e, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x3a, 0x20, 0x54, 0x4c, 0x53, 0x2d, 0x45, 0x43, 0x44,
706     0x48, 0x45, 0x2d, 0x45, 0x43, 0x44, 0x53, 0x41, 0x2d, 0x57, 0x49, 0x54, 0x48, 0x2d, 0x41, 0x45,
707     0x53, 0x2d, 0x31, 0x32, 0x38, 0x2d, 0x43, 0x43, 0x4d, 0x3c, 0x2f, 0x70, 0x3e, 0x0d, 0x0a
708 };
709 size_t control_server_message_ECDHE_ECDSA_WITH_AES_128_CCM_len = sizeof(control_server_message_ECDHE_ECDSA_WITH_AES_128_CCM);
710
711 unsigned char control_server_message_ECDHE_ECDSA_WITH_AES_128_CCM_8[] = {
712     0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x20, 0x32, 0x30, 0x30, 0x20, 0x4f, 0x4b, 0x0d,
713     0x0a, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x54, 0x79, 0x70, 0x65, 0x3a, 0x20, 0x74,
714     0x65, 0x78, 0x74, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x0d, 0x0a, 0x0d, 0x0a, 0x3c, 0x68, 0x32, 0x3e,
715     0x6d, 0x62, 0x65, 0x64, 0x20, 0x54, 0x4c, 0x53, 0x20, 0x54, 0x65, 0x73, 0x74, 0x20, 0x53, 0x65,
716     0x72, 0x76, 0x65, 0x72, 0x3c, 0x2f, 0x68, 0x32, 0x3e, 0x0d, 0x0a, 0x54, 0x45, 0x53, 0x54, 0x20,
717     0x4d, 0x45, 0x53, 0x53, 0x41, 0x47, 0x45, 0x0d, 0x0a, 0x3c, 0x70, 0x3e, 0x53, 0x75, 0x63, 0x63,
718     0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f,
719     0x6e, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x3a, 0x20, 0x54, 0x4c, 0x53, 0x2d, 0x45, 0x43, 0x44,
720     0x48, 0x45, 0x2d, 0x45, 0x43, 0x44, 0x53, 0x41, 0x2d, 0x57, 0x49, 0x54, 0x48, 0x2d, 0x41, 0x45,
721     0x53, 0x2d, 0x31, 0x32, 0x38, 0x2d, 0x43, 0x43, 0x4d, 0x2d, 0x38, 0x3c, 0x2f, 0x70, 0x3e, 0x0d,
722     0x0a
723 };
724 size_t control_server_message_ECDHE_ECDSA_WITH_AES_128_CCM_8_len = sizeof(control_server_message_ECDHE_ECDSA_WITH_AES_128_CCM_8);
725
726 unsigned char control_server_message_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256[] = {
727     0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x20, 0x32, 0x30, 0x30, 0x20, 0x4f, 0x4b, 0x0d,
728     0x0a, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x54, 0x79, 0x70, 0x65, 0x3a, 0x20, 0x74,
729     0x65, 0x78, 0x74, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x0d, 0x0a, 0x0d, 0x0a, 0x3c, 0x68, 0x32, 0x3e,
730     0x6d, 0x62, 0x65, 0x64, 0x20, 0x54, 0x4c, 0x53, 0x20, 0x54, 0x65, 0x73, 0x74, 0x20, 0x53, 0x65,
731     0x72, 0x76, 0x65, 0x72, 0x3c, 0x2f, 0x68, 0x32, 0x3e, 0x0d, 0x0a, 0x54, 0x45, 0x53, 0x54, 0x20,
732     0x4d, 0x45, 0x53, 0x53, 0x41, 0x47, 0x45, 0x0d, 0x0a, 0x3c, 0x70, 0x3e, 0x53, 0x75, 0x63, 0x63,
733     0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f,
734     0x6e, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x3a, 0x20, 0x54, 0x4c, 0x53, 0x2d, 0x45, 0x43, 0x44,
735     0x48, 0x45, 0x2d, 0x45, 0x43, 0x44, 0x53, 0x41, 0x2d, 0x57, 0x49, 0x54, 0x48, 0x2d, 0x41, 0x45,
736     0x53, 0x2d, 0x31, 0x32, 0x38, 0x2d, 0x43, 0x42, 0x43, 0x2d, 0x53, 0x48, 0x41, 0x32, 0x35, 0x36,
737     0x3c, 0x2f, 0x70, 0x3e, 0x0d, 0x0a
738 };
739 size_t control_server_message_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256_len = sizeof(control_server_message_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256);
740
741 unsigned char control_server_message_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256[] = {
742     0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x20, 0x32, 0x30, 0x30, 0x20, 0x4f, 0x4b, 0x0d,
743     0x0a, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x54, 0x79, 0x70, 0x65, 0x3a, 0x20, 0x74,
744     0x65, 0x78, 0x74, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x0d, 0x0a, 0x0d, 0x0a, 0x3c, 0x68, 0x32, 0x3e,
745     0x6d, 0x62, 0x65, 0x64, 0x20, 0x54, 0x4c, 0x53, 0x20, 0x54, 0x65, 0x73, 0x74, 0x20, 0x53, 0x65,
746     0x72, 0x76, 0x65, 0x72, 0x3c, 0x2f, 0x68, 0x32, 0x3e, 0x0d, 0x0a, 0x54, 0x45, 0x53, 0x54, 0x20,
747     0x4d, 0x45, 0x53, 0x53, 0x41, 0x47, 0x45, 0x0d, 0x0a, 0x3c, 0x70, 0x3e, 0x53, 0x75, 0x63, 0x63,
748     0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f,
749     0x6e, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x3a, 0x20, 0x54, 0x4c, 0x53, 0x2d, 0x45, 0x43, 0x44,
750     0x48, 0x45, 0x2d, 0x45, 0x43, 0x44, 0x53, 0x41, 0x2d, 0x57, 0x49, 0x54, 0x48, 0x2d, 0x41, 0x45,
751     0x53, 0x2d, 0x31, 0x32, 0x38, 0x2d, 0x47, 0x43, 0x4D, 0x2d, 0x53, 0x48, 0x41, 0x32, 0x35, 0x36,
752     0x3c, 0x2f, 0x70, 0x3e, 0x0d, 0x0a
753 };
754 size_t control_server_message_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256_len = sizeof(control_server_message_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256);
755
756 unsigned char control_server_message_ECDHE_ECDSA_WITH_AES_128_CBC_SHA[] = {
757     0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x20, 0x32, 0x30, 0x30, 0x20, 0x4f, 0x4b, 0x0d,
758     0x0a, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x54, 0x79, 0x70, 0x65, 0x3a, 0x20, 0x74,
759     0x65, 0x78, 0x74, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x0d, 0x0a, 0x0d, 0x0a, 0x3c, 0x68, 0x32, 0x3e,
760     0x6d, 0x62, 0x65, 0x64, 0x20, 0x54, 0x4c, 0x53, 0x20, 0x54, 0x65, 0x73, 0x74, 0x20, 0x53, 0x65,
761     0x72, 0x76, 0x65, 0x72, 0x3c, 0x2f, 0x68, 0x32, 0x3e, 0x0d, 0x0a, 0x54, 0x45, 0x53, 0x54, 0x20,
762     0x4d, 0x45, 0x53, 0x53, 0x41, 0x47, 0x45, 0x0d, 0x0a, 0x3c, 0x70, 0x3e, 0x53, 0x75, 0x63, 0x63,
763     0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f,
764     0x6e, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x3a, 0x20, 0x54, 0x4c, 0x53, 0x2d, 0x45, 0x43, 0x44,
765     0x48, 0x45, 0x2d, 0x45, 0x43, 0x44, 0x53, 0x41, 0x2d, 0x57, 0x49, 0x54, 0x48, 0x2d, 0x41, 0x45,
766     0x53, 0x2d, 0x31, 0x32, 0x38, 0x2d, 0x43, 0x42, 0x43, 0x2d, 0x53, 0x48, 0x41, 0x3c, 0x2f, 0x70,
767     0x3e, 0x0d, 0x0a
768 };
769 size_t control_server_message_ECDHE_ECDSA_WITH_AES_128_CBC_SHA_len = sizeof(control_server_message_ECDHE_ECDSA_WITH_AES_128_CBC_SHA);
770
771 unsigned char control_client_message[] = {
772     0x47, 0x45, 0x54, 0x20, 0x2f, 0x20, 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x0d, 0x0a,
773     0x0d, 0x0a
774 };
775 size_t control_client_message_len = sizeof(control_client_message);
776
777 unsigned char control_server_message_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384[] = {
778     0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x20, 0x32, 0x30, 0x30, 0x20, 0x4f, 0x4b, 0x0d,
779     0x0a, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x54, 0x79, 0x70, 0x65, 0x3a, 0x20, 0x74,
780     0x65, 0x78, 0x74, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x0d, 0x0a, 0x0d, 0x0a, 0x3c, 0x68, 0x32, 0x3e,
781     0x6d, 0x62, 0x65, 0x64, 0x20, 0x54, 0x4c, 0x53, 0x20, 0x54, 0x65, 0x73, 0x74, 0x20, 0x53, 0x65,
782     0x72, 0x76, 0x65, 0x72, 0x3c, 0x2f, 0x68, 0x32, 0x3e, 0x0d, 0x0a, 0x54, 0x45, 0x53, 0x54, 0x20,
783     0x4d, 0x45, 0x53, 0x53, 0x41, 0x47, 0x45, 0x0d, 0x0a, 0x3c, 0x70, 0x3e, 0x53, 0x75, 0x63, 0x63,
784     0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f,
785     0x6e, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x3a, 0x20, 0x54, 0x4c, 0x53, 0x2d, 0x45, 0x43, 0x44,
786     0x48, 0x45, 0x2d, 0x45, 0x43, 0x44, 0x53, 0x41, 0x2d, 0x57, 0x49, 0x54, 0x48, 0x2d, 0x41, 0x45,
787     0x53, 0x2d, 0x32, 0x35, 0x36, 0x2d, 0x43, 0x42, 0x43, 0x2d, 0x53, 0x48, 0x41, 0x33, 0x38, 0x34,
788     0x3c, 0x2f, 0x70, 0x3e, 0x0d, 0x0a
789 };
790 size_t control_server_message_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384_len = sizeof(control_server_message_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384);
791
792 unsigned char control_server_message_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384[] = {
793     0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x20, 0x32, 0x30, 0x30, 0x20, 0x4f, 0x4b, 0x0d,
794     0x0a, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x54, 0x79, 0x70, 0x65, 0x3a, 0x20, 0x74,
795     0x65, 0x78, 0x74, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x0d, 0x0a, 0x0d, 0x0a, 0x3c, 0x68, 0x32, 0x3e,
796     0x6d, 0x62, 0x65, 0x64, 0x20, 0x54, 0x4c, 0x53, 0x20, 0x54, 0x65, 0x73, 0x74, 0x20, 0x53, 0x65,
797     0x72, 0x76, 0x65, 0x72, 0x3c, 0x2f, 0x68, 0x32, 0x3e, 0x0d, 0x0a, 0x54, 0x45, 0x53, 0x54, 0x20,
798     0x4d, 0x45, 0x53, 0x53, 0x41, 0x47, 0x45, 0x0d, 0x0a, 0x3c, 0x70, 0x3e, 0x53, 0x75, 0x63, 0x63,
799     0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x20, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f,
800     0x6e, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x3a, 0x20, 0x54, 0x4c, 0x53, 0x2d, 0x45, 0x43, 0x44,
801     0x48, 0x45, 0x2d, 0x45, 0x43, 0x44, 0x53, 0x41, 0x2d, 0x57, 0x49, 0x54, 0x48, 0x2d, 0x41, 0x45,
802     0x53, 0x2d, 0x32, 0x35, 0x36, 0x2d, 0x47, 0x43, 0x4D, 0x2d, 0x53, 0x48, 0x41, 0x33, 0x38, 0x34,
803     0x3c, 0x2f, 0x70, 0x3e, 0x0d, 0x0a
804 };
805 size_t control_server_message_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384_len = sizeof(control_server_message_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384);
806
807 void printHexArray(unsigned char *m, size_t len, size_t cols)
808 {
809     for(size_t i = 0; i < len; i++)
810     {
811         mbedtls_printf("0x%02x", m[i]);
812         if (i != len - 1)
813         {
814             mbedtls_printf(", ");
815         }
816         if (i > 0 && (i + 1) % cols == 0)
817         {
818             mbedtls_printf("\n");
819         }
820     }
821     mbedtls_printf("\n");
822 }
823
824 static volatile bool socket_error = false;
825
826 static void error(const char *msg)
827 {
828     socket_error = true;
829     perror(msg);
830 }
831
832 static CASocketFd_t sockfd, newsockfd;
833
834 static void socketClose()
835 {
836     OC_CLOSE_SOCKET(sockfd);
837 }
838
839 static bool socketConnect()
840 {
841     struct addrinfo* addressInfo = NULL;
842     struct addrinfo hints;
843
844     memset(&hints, 0, sizeof(struct addrinfo));
845     hints.ai_family = AF_INET;
846
847     sockfd = socket(AF_INET, SOCK_STREAM, 0);
848     if (sockfd < 0)
849     {
850         error("ERROR opening socket");
851         return false;
852     }
853
854     int result = getaddrinfo(SERVER_NAME, SERVER_PORT_STRING, &hints, &addressInfo);
855     if (0 != result)
856     {
857         error("ERROR, no such host");
858         socketClose();
859         return false;
860     }
861
862     if (connect(sockfd, addressInfo->ai_addr, (int)addressInfo->ai_addrlen) < 0)
863     {
864         error("ERROR connecting");
865         socketClose();
866         freeaddrinfo(addressInfo);
867         return false;
868     }
869
870     freeaddrinfo(addressInfo);
871     return true;
872 }
873
874 static ssize_t CATCPPacketSendCB(CAEndpoint_t *, const void *buf, size_t buflen)
875 {
876     int n = send(sockfd, (const char*)buf, (int)buflen, 0);
877     if (n < 0)
878     {
879         error("ERROR writing to socket");
880     }
881     return n;
882 }
883
884 char msg[256] = {0}; size_t msglen = 0;
885 static void CATCPPacketReceivedCB(const CASecureEndpoint_t *, const void *data, size_t dataLength)
886 {
887     memcpy(msg, data, dataLength);
888     msglen = dataLength;
889 }
890
891 static void PacketReceive(unsigned char *data, int * datalen)
892 {
893     int n;
894     char buffer[2048] = {'\0'};
895     n = recv(sockfd, buffer, 5, 0);
896     if ((buffer[0] == 0x16 || buffer[0] == 0x14 || buffer[0] == 0x17 || buffer[0] == 0x15)
897         && buffer[1] == 0x03 && buffer[2] == 0x03)
898     {
899         int tlslen = (unsigned char)buffer[3] * 0x100 + (unsigned char)buffer[4];
900         n = recv(sockfd, buffer + 5, tlslen, 0);
901     }
902
903     if (n < 0)
904     {
905         error("ERROR reading from socket");
906         *datalen = 0;
907         return;
908     }
909
910     *datalen = n + 5;
911     memcpy(data, buffer, *datalen);
912 }
913
914 static void infoCallback_that_loads_x509(PkiInfo_t * inf)
915 {
916     inf->crt.len = sizeof(serverCert);
917     inf->crt.data = (uint8_t*)OICMalloc(inf->crt.len);
918     ASSERT_TRUE(inf->crt.data != NULL);
919     memcpy(inf->crt.data, serverCert, inf->crt.len);
920
921     inf->key.len = sizeof(serverPrivateKey);
922     inf->key.data = (uint8_t*)OICMalloc(inf->key.len);
923     ASSERT_TRUE(inf->key.data != NULL);
924     memcpy(inf->key.data, serverPrivateKey, inf->key.len);
925
926
927     inf->ca.len = sizeof(caCert);
928     inf->ca.data = (uint8_t*)OICMalloc(inf->ca.len);
929     ASSERT_TRUE(inf->ca.data != NULL);
930     memcpy(inf->ca.data, caCert, inf->ca.len);
931
932
933     inf->crl.data = NULL;
934     inf->crl.len = 0;
935 }
936
937 static bool socketOpen_server()
938 {
939     unsigned short portno;
940     struct sockaddr_in serv_addr, cli_addr;
941     socklen_t clilen;
942
943 #ifdef HAVE_WINSOCK2_H
944     WORD wVersionRequested = MAKEWORD(2, 2);
945     WSADATA wsaData;
946     int err = WSAStartup(wVersionRequested, &wsaData);
947     if (err)
948     {
949         error("WSAStartup error");
950         return false;
951     }
952 #endif
953
954     portno = SERVER_PORT;
955     sockfd = socket(AF_INET, SOCK_STREAM, 0);
956     if (sockfd < 0)
957     {
958         error("\nERROR opening socket");
959         return false;
960     }
961     //bzero((char *) &serv_addr, sizeof(serv_addr));
962     memset((void*)&serv_addr, 0, sizeof(serv_addr));
963     serv_addr.sin_family = AF_INET;
964     serv_addr.sin_addr.s_addr = INADDR_ANY;
965     serv_addr.sin_port = htons(portno);
966     if (bind(sockfd, (struct sockaddr *) &serv_addr,
967               sizeof(serv_addr)) < 0)
968     {
969         error("\nERROR on binding");
970         socketClose();
971         return false;
972     }
973     listen(sockfd,5);
974     clilen = sizeof(cli_addr);
975     newsockfd = accept(sockfd,
976                  (struct sockaddr *) &cli_addr,
977                  &clilen);
978     if (newsockfd < 0)
979     {
980         error("\nERROR on accept");
981         socketClose();
982         return false;
983     }
984     return true;
985 }
986
987 static ssize_t CATCPPacketSendCB_server(CAEndpoint_t *, const void *buf, size_t buflen)
988 {
989     int n;
990     n = send(newsockfd, (const char*)buf, (int)buflen, 0);
991     if (n < 0)
992     {
993         error("ERROR writing to socket");
994     }
995     return n;
996 }
997
998 static void CATCPPacketReceivedCB_server(const CASecureEndpoint_t *, const void *data, size_t dataLength)
999 {
1000     memcpy(msg, data, dataLength);
1001     msglen = dataLength;
1002 }
1003
1004 static void PacketReceive_server(unsigned char *data, int * datalen)
1005 {
1006     int n;
1007     char buffer[2048] = {'\0'};
1008     n = recv(newsockfd, buffer, 5, 0);
1009
1010     if (buffer[0] == 0x16 || buffer[0] == 0x14 || buffer[0] == 0x17 || buffer[0] == 0x15)
1011     {
1012         int tlslen = (unsigned char)buffer[3] * 0x100 + (unsigned char)buffer[4];
1013         n = recv(newsockfd, buffer + 5, tlslen, 0);
1014     }
1015
1016     if (n < 0)
1017     {
1018         error("\nERROR reading from socket");
1019         *datalen = n;
1020         return;
1021     }
1022
1023     *datalen = n + 5;
1024     memcpy(data, buffer, *datalen);
1025 }
1026
1027 static void socketClose_server()
1028 {
1029     OC_CLOSE_SOCKET(newsockfd);
1030     OC_CLOSE_SOCKET(sockfd);
1031 }
1032
1033 static void clutch(bool * list, const char *deviceId)
1034 {
1035     OC_UNUSED(deviceId);
1036
1037     list[1] = true;
1038 }
1039
1040 const unsigned char IDENTITY[] = ("6767676767676767");
1041 const unsigned char RS_CLIENT_PSK[] = ("AAAAAAAAAAAAAAAA");
1042 static int32_t GetDtlsPskCredentials( CADtlsPskCredType_t,
1043               const unsigned char *, size_t,
1044               unsigned char *result, size_t)
1045 {
1046     int32_t ret = -1;
1047
1048     if (NULL == result)
1049     {
1050         return ret;
1051     }
1052     memcpy(result, IDENTITY, sizeof(IDENTITY));
1053     ret = sizeof(IDENTITY);
1054
1055     return ret;
1056 }
1057
1058 /* **************************
1059  *
1060  *
1061  * MbedTLS client routine
1062  *
1063  *
1064  * *************************/
1065
1066 #if !defined(MBEDTLS_CONFIG_FILE)
1067 #include "mbedtls/config.h"
1068 #else
1069 #include MBEDTLS_CONFIG_FILE
1070 #endif
1071
1072 #if defined(MBEDTLS_PLATFORM_C)
1073 #include "mbedtls/platform.h"
1074 #else
1075 #include <stdio.h>
1076 #include <stdlib.h>
1077 #define mbedtls_fprintf    fprintf
1078 #define mbedtls_printf     printf
1079 #endif
1080
1081 #if !defined(MBEDTLS_BIGNUM_C) || !defined(MBEDTLS_ENTROPY_C) ||  \
1082     !defined(MBEDTLS_SSL_TLS_C) || !defined(MBEDTLS_SSL_CLI_C) || \
1083     !defined(MBEDTLS_NET_C) || !defined(MBEDTLS_RSA_C) ||         \
1084     !defined(MBEDTLS_PEM_PARSE_C) ||!defined(MBEDTLS_CTR_DRBG_C) || \
1085     !defined(MBEDTLS_X509_CRT_PARSE_C)
1086 static int client( void )
1087 {
1088     mbedtls_printf("MBEDTLS_BIGNUM_C and/or MBEDTLS_ENTROPY_C and/or "
1089            "MBEDTLS_SSL_TLS_C and/or MBEDTLS_SSL_CLI_C and/or "
1090            "MBEDTLS_NET_C and/or MBEDTLS_RSA_C and/or "
1091            "MBEDTLS_CTR_DRBG_C and/or MBEDTLS_X509_CRT_PARSE_C "
1092            "not defined.\n");
1093     return( 0 );
1094 }
1095 #else
1096
1097 #include "mbedtls/net_sockets.h"
1098 #include "mbedtls/debug.h"
1099 #include "mbedtls/ssl.h"
1100 #include "mbedtls/entropy.h"
1101 #include "mbedtls/ctr_drbg.h"
1102 #include "mbedtls/error.h"
1103
1104
1105 #include <string.h>
1106
1107 #define DEBUG_LEVEL (0)
1108
1109 static void my_debug_client( void *ctx, int level,
1110                       const char *file, int line,
1111                       const char *str )
1112 {
1113     ((void) level);
1114
1115     mbedtls_fprintf( (FILE *) ctx, "%s:%04d: %s", file, line, str );
1116     fflush(  (FILE *) ctx  );
1117 }
1118
1119 static void * client(void *)
1120 {
1121     int ret, len;
1122     mbedtls_net_context server_fd;
1123     uint32_t flags;
1124     unsigned char buf[1024];
1125     const char *pers = "ssl_client1";
1126
1127     mbedtls_entropy_context entropy;
1128     mbedtls_ctr_drbg_context ctr_drbg;
1129     mbedtls_ssl_context ssl;
1130     mbedtls_ssl_config conf;
1131     mbedtls_x509_crt cacert;
1132     mbedtls_x509_crt owncert;
1133     mbedtls_pk_context pkey;
1134
1135     /*
1136      * 0. Initialize the RNG and the session data
1137      */
1138     mbedtls_net_init( &server_fd );
1139     mbedtls_ssl_init( &ssl );
1140     mbedtls_ssl_config_init( &conf );
1141     mbedtls_x509_crt_init( &cacert );
1142     mbedtls_x509_crt_init( &owncert );
1143     mbedtls_ctr_drbg_init( &ctr_drbg );
1144     mbedtls_pk_init( &pkey );
1145
1146     mbedtls_printf( "\n  . Seeding the random number generator..." );
1147     fflush( stdout );
1148
1149     mbedtls_entropy_init( &entropy );
1150     if( ( ret = mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func, &entropy,
1151                                (const unsigned char *) pers,
1152                                strlen( pers ) ) ) != 0 )
1153     {
1154         mbedtls_printf( " failed\n  ! mbedtls_ctr_drbg_seed returned %d\n", ret );
1155         goto exit;
1156     }
1157
1158     mbedtls_printf( " ok\n" );
1159
1160     /*
1161      * 0. Initialize certificates
1162      */
1163     mbedtls_printf( "  . Loading the CA root certificate ..." );
1164     fflush( stdout );
1165     ret = mbedtls_x509_crt_parse( &cacert, (const unsigned char *) caCert, caCertLen );
1166     if( ret < 0 )
1167     {
1168         mbedtls_printf( " failed\n  !  mbedtls_x509_crt_parse caCert returned -0x%x\n\n", -ret );
1169         goto exit;
1170     }
1171     ret = mbedtls_x509_crt_parse( &owncert, (const unsigned char *) serverCert, serverCertLen );
1172     if( ret < 0 )
1173     {
1174         mbedtls_printf( " failed\n  !  mbedtls_x509_crt_parse serverCert returned -0x%x\n\n", -ret );
1175         goto exit;
1176     }
1177     ret =  mbedtls_pk_parse_key( &pkey, (const unsigned char *) serverPrivateKey,
1178                                                                 serverPrivateKeyLen, NULL, 0 );
1179     if( ret < 0 )
1180     {
1181         mbedtls_printf( " failed\n  !  mbedtls_pk_parse_key returned -0x%x\n\n", -ret );
1182         goto exit;
1183     }
1184
1185     mbedtls_printf( " ok (%d skipped)\n", ret );
1186
1187     /*
1188      * 1. Start the connection
1189      */
1190     mbedtls_printf( "  . Connecting to tcp/%s/%s...", SERVER_NAME, "SERVER_PORT" );
1191     fflush( stdout );
1192
1193     if( ( ret = mbedtls_net_connect( &server_fd, "127.0.0.1",
1194                                          "4433", MBEDTLS_NET_PROTO_TCP ) ) != 0 )
1195     {
1196         mbedtls_printf( " failed\n  ! mbedtls_net_connect returned %d\n\n", ret );
1197         goto exit;
1198     }
1199
1200     mbedtls_printf( " ok\n" );
1201
1202     /*
1203      * 2. Setup stuff
1204      */
1205     mbedtls_printf( "  . Setting up the SSL/TLS structure..." );
1206     fflush( stdout );
1207
1208     if( ( ret = mbedtls_ssl_config_defaults( &conf,
1209                     MBEDTLS_SSL_IS_CLIENT,
1210                     MBEDTLS_SSL_TRANSPORT_STREAM,
1211                     MBEDTLS_SSL_PRESET_DEFAULT ) ) != 0 )
1212     {
1213         mbedtls_printf( " failed\n  ! mbedtls_ssl_config_defaults returned %d\n\n", ret );
1214         goto exit;
1215     }
1216
1217     mbedtls_printf( " ok\n" );
1218
1219     /* OPTIONAL is not optimal for security,
1220      * but makes interop easier in this simplified example */
1221     mbedtls_ssl_conf_authmode( &conf, MBEDTLS_SSL_VERIFY_OPTIONAL );
1222     mbedtls_ssl_conf_ca_chain( &conf, &cacert, NULL );
1223     mbedtls_ssl_conf_own_cert( &conf, &owncert, &pkey );
1224     mbedtls_ssl_conf_rng( &conf, mbedtls_ctr_drbg_random, &ctr_drbg );
1225     mbedtls_ssl_conf_dbg( &conf, my_debug_client, stdout );
1226
1227     if( ( ret = mbedtls_ssl_setup( &ssl, &conf ) ) != 0 )
1228     {
1229         mbedtls_printf( " failed\n  ! mbedtls_ssl_setup returned %d\n\n", ret );
1230         goto exit;
1231     }
1232
1233     if( ( ret = mbedtls_ssl_set_hostname( &ssl, "mbed TLS Server 1" ) ) != 0 )
1234     {
1235         mbedtls_printf( " failed\n  ! mbedtls_ssl_set_hostname returned %d\n\n", ret );
1236         goto exit;
1237     }
1238
1239     mbedtls_ssl_set_bio( &ssl, &server_fd, mbedtls_net_send, mbedtls_net_recv, NULL );
1240
1241     /*
1242      * 4. Handshake
1243      */
1244     mbedtls_printf( "  . Performing the SSL/TLS handshake..." );
1245     fflush( stdout );
1246
1247     while( ( ret = mbedtls_ssl_handshake( &ssl ) ) != 0 )
1248     {
1249         if( ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE )
1250         {
1251             mbedtls_printf( " failed\n  ! mbedtls_ssl_handshake returned -0x%x\n\n", -ret );
1252             goto exit;
1253         }
1254     }
1255
1256     mbedtls_printf( " ok\n" );
1257
1258     /*
1259      * 5. Verify the server certificate
1260      */
1261     mbedtls_printf( "  . Verifying peer X.509 certificate..." );
1262
1263     /* In real life, we probably want to bail out when ret != 0 */
1264     if( ( flags = mbedtls_ssl_get_verify_result( &ssl ) ) != 0 )
1265     {
1266         char vrfy_buf[512];
1267
1268         mbedtls_printf( " failed\n" );
1269
1270         mbedtls_x509_crt_verify_info( vrfy_buf, sizeof( vrfy_buf ), "  ! ", flags );
1271
1272         mbedtls_printf( "%s\n", vrfy_buf );
1273     }
1274     else
1275         mbedtls_printf( " ok\n" );
1276
1277     /*
1278      * 3. Write the GET request
1279      */
1280     mbedtls_printf( "  > Write to server:" );
1281     fflush( stdout );
1282
1283     len = sprintf( (char *) buf, GET_REQUEST );
1284
1285     while( ( ret = mbedtls_ssl_write( &ssl, buf, len ) ) <= 0 )
1286     {
1287         if( ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE )
1288         {
1289             mbedtls_printf( " failed\n  ! mbedtls_ssl_write returned %d\n\n", ret );
1290             goto exit;
1291         }
1292     }
1293
1294     len = ret;
1295     mbedtls_printf( " %d bytes written\n\n%s", len, (char *) buf );
1296
1297     /*
1298      * 7. Read the HTTP response
1299      */
1300     mbedtls_printf( "  < Read from server:" );
1301     fflush( stdout );
1302
1303     do
1304     {
1305         len = sizeof( buf ) - 1;
1306         memset( buf, 0, sizeof( buf ) );
1307         ret = mbedtls_ssl_read( &ssl, buf, len );
1308
1309         if( ret == MBEDTLS_ERR_SSL_WANT_READ || ret == MBEDTLS_ERR_SSL_WANT_WRITE )
1310             continue;
1311
1312         if( ret == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY )
1313             break;
1314
1315         if( ret < 0 )
1316         {
1317             mbedtls_printf( "failed\n  ! mbedtls_ssl_read returned %d\n\n", ret );
1318             break;
1319         }
1320
1321         if( ret == 0 )
1322         {
1323             mbedtls_printf( "\n\nEOF\n\n" );
1324             break;
1325         }
1326
1327         len = ret;
1328         mbedtls_printf( " %d bytes read\n\n%s", len, (char *) buf );
1329     }
1330     while( 1 );
1331
1332     mbedtls_ssl_close_notify( &ssl );
1333
1334 exit:
1335
1336 #ifdef MBEDTLS_ERROR_C
1337     if( ret != 0 )
1338     {
1339         char error_buf[100];
1340         mbedtls_strerror( ret, error_buf, 100 );
1341         mbedtls_printf("Last error was: %d - %s\n\n", ret, error_buf );
1342     }
1343 #endif
1344
1345     mbedtls_net_free( &server_fd );
1346
1347     mbedtls_x509_crt_free( &cacert );
1348     mbedtls_ssl_free( &ssl );
1349     mbedtls_ssl_config_free( &conf );
1350     mbedtls_ctr_drbg_free( &ctr_drbg );
1351     mbedtls_entropy_free( &entropy );
1352
1353     return NULL;
1354 }
1355 #endif /* MBEDTLS_BIGNUM_C && MBEDTLS_ENTROPY_C && MBEDTLS_SSL_TLS_C &&
1356           MBEDTLS_SSL_CLI_C && MBEDTLS_NET_C && MBEDTLS_RSA_C &&
1357           MBEDTLS_PEM_PARSE_C && MBEDTLS_CTR_DRBG_C &&
1358           MBEDTLS_X509_CRT_PARSE_C */
1359
1360 /* **************************
1361  *
1362  *
1363  * MbedTLS server routine
1364  *
1365  *
1366  * *************************/
1367
1368 #if !defined(MBEDTLS_CONFIG_FILE)
1369 #include "mbedtls/config.h"
1370 #else
1371 #include MBEDTLS_CONFIG_FILE
1372 #endif
1373
1374 #if defined(MBEDTLS_PLATFORM_C)
1375 #include "mbedtls/platform.h"
1376 #else
1377 #include <stdio.h>
1378 #include <stdlib.h>
1379 #define mbedtls_fprintf    fprintf
1380 #define mbedtls_printf     printf
1381 #endif
1382
1383 #if !defined(MBEDTLS_BIGNUM_C) || !defined(MBEDTLS_PEM_PARSE_C)|| \
1384     !defined(MBEDTLS_ENTROPY_C) || !defined(MBEDTLS_SSL_TLS_C) || \
1385     !defined(MBEDTLS_SSL_SRV_C) || !defined(MBEDTLS_NET_C) ||     \
1386     !defined(MBEDTLS_RSA_C) || !defined(MBEDTLS_CTR_DRBG_C) ||    \
1387     !defined(MBEDTLS_X509_CRT_PARSE_C) || !defined(MBEDTLS_FS_IO) 
1388
1389 /* int */void * server( void )
1390 {
1391     mbedtls_printf("MBEDTLS_BIGNUM_C and/or MBEDTLS_ENTROPY_C "
1392            "and/or MBEDTLS_SSL_TLS_C and/or MBEDTLS_SSL_SRV_C and/or "
1393            "MBEDTLS_NET_C and/or MBEDTLS_RSA_C and/or "
1394            "MBEDTLS_CTR_DRBG_C and/or MBEDTLS_X509_CRT_PARSE_C "
1395            "and/or MBEDTLS_PEM_PARSE_C not defined.\n");
1396     return(/* 0 */);
1397 }
1398 #else
1399
1400 #include <stdlib.h>
1401 #include <string.h>
1402
1403 #include "mbedtls/entropy.h"
1404 #include "mbedtls/ctr_drbg.h"
1405 #include "mbedtls/x509.h"
1406 #include "mbedtls/ssl.h"
1407 #include "mbedtls/net_sockets.h"
1408 #include "mbedtls/error.h"
1409 #include "mbedtls/debug.h"
1410
1411 #if defined(MBEDTLS_SSL_CACHE_C)
1412 #include "mbedtls/ssl_cache.h"
1413 #endif
1414
1415 #define HTTP_RESPONSE \
1416     "HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n" \
1417     "<h2>mbed TLS Test Server</h2>\r\n" \
1418     "TEST MESSAGE\r\n" \
1419     "<p>Successful connection using: %s</p>\r\n"
1420
1421 #define DEBUG_LEVEL (0)
1422
1423 static int mbedtls_entropy_func_clutch(void *, unsigned char *output, size_t len)
1424 {
1425     for (uint32_t i = 0; i < len; i++) output[i] = 0x11;
1426     return 0;
1427 }
1428
1429 static void my_debug( void *ctx, int level,
1430                       const char *file, int line,
1431                       const char *str )
1432 {
1433     ((void) level);
1434
1435     mbedtls_fprintf((FILE *) ctx, "%s:%04d: %s", file, line, str);
1436     fflush(  (FILE *) ctx  );
1437 }
1438
1439 static void * server(void *)
1440 {
1441     int ret, len;
1442     mbedtls_net_context listen_fd, client_fd;
1443     unsigned char buf[1024];
1444     const char *pers = "ssl_server";
1445
1446     mbedtls_entropy_context entropy;
1447     mbedtls_ctr_drbg_context ctr_drbg;
1448     mbedtls_ssl_context ssl;
1449     mbedtls_ssl_config conf;
1450     mbedtls_x509_crt srvcert;
1451     mbedtls_pk_context pkey;
1452 #if defined(MBEDTLS_SSL_CACHE_C)
1453     mbedtls_ssl_cache_context cache;
1454 #endif
1455
1456     mbedtls_net_init( &listen_fd );
1457     mbedtls_net_init( &client_fd );
1458     mbedtls_ssl_init( &ssl );
1459     mbedtls_ssl_config_init( &conf );
1460 #if defined(MBEDTLS_SSL_CACHE_C)
1461     mbedtls_ssl_cache_init( &cache );
1462 #endif
1463     mbedtls_x509_crt_init( &srvcert );
1464     mbedtls_pk_init( &pkey );
1465     mbedtls_entropy_init( &entropy );
1466     mbedtls_ctr_drbg_init( &ctr_drbg );
1467
1468 #if defined(MBEDTLS_DEBUG_C)
1469     mbedtls_debug_set_threshold( DEBUG_LEVEL );
1470 #endif
1471
1472     /*
1473      * 1. Load the certificates and private RSA key
1474      */
1475     mbedtls_printf( "\n  . Loading the server cert. and key..." );
1476     fflush( stdout );
1477
1478     /*
1479      * This demonstration program uses embedded test certificates.
1480      * Instead, you may want to use mbedtls_x509_crt_parse_file() to read the
1481      * server and CA certificates, as well as mbedtls_pk_parse_keyfile().
1482      */
1483     ret = mbedtls_x509_crt_parse( &srvcert, (const unsigned char *) serverCert, serverCertLen );
1484     if( ret != 0 )
1485     {
1486         mbedtls_printf( " failed\n  !  mbedtls_x509_crt_parse returned %d\n\n", ret );
1487         goto exit;
1488     }
1489
1490     ret = mbedtls_x509_crt_parse( &srvcert, (const unsigned char *) caCert, caCertLen );
1491     if( ret != 0 )
1492     {
1493         mbedtls_printf( " failed\n  !  mbedtls_x509_crt_parse returned %d\n\n", ret );
1494         goto exit;
1495     }
1496
1497     ret =  mbedtls_pk_parse_key( &pkey, (const unsigned char *) serverPrivateKey,
1498                                                                 serverPrivateKeyLen, NULL, 0 );
1499     if( ret != 0 )
1500     {
1501         mbedtls_printf( " failed\n  !  mbedtls_pk_parse_key returned %d\n\n", ret );
1502         goto exit;
1503     }
1504
1505     mbedtls_printf( " ok\n" );
1506
1507     /*
1508      * 2. Setup the listening TCP socket
1509      */
1510     mbedtls_printf( "  . Bind on https://localhost:4433/ ..." );
1511     fflush( stdout );
1512
1513     if( ( ret = mbedtls_net_bind( &listen_fd, NULL, "4433", MBEDTLS_NET_PROTO_TCP ) ) != 0 )
1514     {
1515         mbedtls_printf( " failed\n  ! mbedtls_net_bind returned %d\n\n", ret );
1516         goto exit;
1517     }
1518
1519     mbedtls_printf( " ok\n" );
1520
1521     /*
1522      * 3. Seed the RNG
1523      */
1524     mbedtls_printf( "  . Seeding the random number generator..." );
1525     fflush( stdout );
1526
1527     if( ( ret = mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func_clutch, &entropy,
1528                                (const unsigned char *) pers,
1529                                strlen( pers ) ) ) != 0 )
1530     {
1531         mbedtls_printf( " failed\n  ! mbedtls_ctr_drbg_seed returned %d\n", ret );
1532     }
1533
1534     mbedtls_printf( " ok\n" );
1535
1536     /*
1537      * 4. Setup stuff
1538      */
1539     mbedtls_printf( "  . Setting up the SSL data...." );
1540     fflush( stdout );
1541
1542     if( ( ret = mbedtls_ssl_config_defaults( &conf,
1543                     MBEDTLS_SSL_IS_SERVER,
1544                     MBEDTLS_SSL_TRANSPORT_STREAM,
1545                     MBEDTLS_SSL_PRESET_DEFAULT ) ) != 0 )
1546     {
1547         mbedtls_printf( " failed\n  ! mbedtls_ssl_config_defaults returned %d\n\n", ret );
1548         goto exit;
1549     }
1550
1551     mbedtls_ssl_conf_rng( &conf, mbedtls_ctr_drbg_random, &ctr_drbg );
1552     mbedtls_ssl_conf_dbg( &conf, my_debug, stdout );
1553
1554 #if defined(MBEDTLS_SSL_CACHE_C)
1555     mbedtls_ssl_conf_session_cache( &conf, &cache,
1556                                    mbedtls_ssl_cache_get,
1557                                    mbedtls_ssl_cache_set );
1558 #endif
1559
1560     mbedtls_ssl_conf_ca_chain( &conf, srvcert.next, NULL );
1561     if( ( ret = mbedtls_ssl_conf_own_cert( &conf, &srvcert, &pkey ) ) != 0 )
1562     {
1563         mbedtls_printf( " failed\n  ! mbedtls_ssl_conf_own_cert returned %d\n\n", ret );
1564         goto exit;
1565     }
1566
1567     if( ( ret = mbedtls_ssl_setup( &ssl, &conf ) ) != 0 )
1568     {
1569         mbedtls_printf( " failed\n  ! mbedtls_ssl_setup returned %d\n\n", ret );
1570         goto exit;
1571     }
1572
1573     mbedtls_printf( " ok\n" );
1574
1575 reset:
1576 #ifdef MBEDTLS_ERROR_C
1577     if( ret != 0 )
1578     {
1579         char error_buf[100];
1580         mbedtls_strerror( ret, error_buf, 100 );
1581         mbedtls_printf("Last error was: %d - %s\n\n", ret, error_buf );
1582     }
1583 #endif
1584
1585     mbedtls_net_free( &client_fd );
1586
1587     mbedtls_ssl_session_reset( &ssl );
1588
1589     /*
1590      * 3. Wait until a client connects
1591      */
1592     mbedtls_printf( "  . Waiting for a remote connection ..." );
1593     fflush( stdout );
1594
1595     if( ( ret = mbedtls_net_accept( &listen_fd, &client_fd,
1596                                     NULL, 0, NULL ) ) != 0 )
1597     {
1598         mbedtls_printf( " failed\n  ! mbedtls_net_accept returned %d\n\n", ret );
1599         goto exit;
1600     }
1601
1602     mbedtls_ssl_set_bio( &ssl, &client_fd, mbedtls_net_send, mbedtls_net_recv, NULL );
1603
1604     mbedtls_printf( " ok\n" );
1605
1606     /*
1607      * 5. Handshake
1608      */
1609     mbedtls_printf( "  . Performing the SSL/TLS handshake..." );
1610     fflush( stdout );
1611
1612     while( ( ret = mbedtls_ssl_handshake( &ssl ) ) != 0 )
1613     {
1614         if( ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE )
1615         {
1616             mbedtls_printf( " failed\n  ! mbedtls_ssl_handshake returned %d\n\n", ret );
1617             goto exit;
1618         }
1619     }
1620
1621     mbedtls_printf( " ok\n" );
1622
1623     /*
1624      * 6. Read the HTTP Request
1625      */
1626     mbedtls_printf( "  < Read from client:" );
1627     fflush( stdout );
1628
1629     do
1630     {
1631         len = sizeof( buf ) - 1;
1632         memset( buf, 0, sizeof( buf ) );
1633         ret = mbedtls_ssl_read( &ssl, buf, len );
1634
1635         if( ret == MBEDTLS_ERR_SSL_WANT_READ || ret == MBEDTLS_ERR_SSL_WANT_WRITE )
1636             continue;
1637
1638         if( ret <= 0 )
1639         {
1640             switch( ret )
1641             {
1642                 case MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY:
1643                     mbedtls_printf( " connection was closed gracefully\n" );
1644                     break;
1645
1646                 case MBEDTLS_ERR_NET_CONN_RESET:
1647                     mbedtls_printf( " connection was reset by peer\n" );
1648                     break;
1649
1650                 default:
1651                     mbedtls_printf( " mbedtls_ssl_read returned -0x%x\n", -ret );
1652                     break;
1653             }
1654
1655             break;
1656         }
1657
1658         len = ret;
1659         mbedtls_printf( " %d bytes read\n\n%s", len, (char *) buf );
1660
1661         if( ret > 0 )
1662             break;
1663     }
1664     while( 1 );
1665
1666     /*
1667      * 7. Write the 200 Response
1668      */
1669     mbedtls_printf( "  > Write to client:" );
1670
1671     fflush( stdout );
1672
1673     len = sprintf( (char *) buf, HTTP_RESPONSE,
1674                    mbedtls_ssl_get_ciphersuite( &ssl ) );
1675
1676     while( ( ret = mbedtls_ssl_write( &ssl, buf, len ) ) <= 0 )
1677     {
1678         if( ret == MBEDTLS_ERR_NET_CONN_RESET )
1679         {
1680             mbedtls_printf( " failed\n  ! peer closed the connection\n\n" );
1681             goto reset;
1682         }
1683
1684         if( ret != MBEDTLS_ERR_SSL_WANT_READ && ret != MBEDTLS_ERR_SSL_WANT_WRITE )
1685         {
1686             mbedtls_printf( " failed\n  ! mbedtls_ssl_write returned %d\n\n", ret );
1687             goto exit;
1688         }
1689     }
1690
1691     len = ret;
1692     mbedtls_printf( " %d bytes written\n\n%s\n", len, (char *) buf );
1693
1694     mbedtls_printf( "  . Closing the connection..." );
1695
1696     while( ( ret = mbedtls_ssl_close_notify( &ssl ) ) < 0 )
1697     {
1698         if( ret != MBEDTLS_ERR_SSL_WANT_READ &&
1699             ret != MBEDTLS_ERR_SSL_WANT_WRITE )
1700         {
1701             mbedtls_printf( " failed\n  ! mbedtls_ssl_close_notify returned %d\n\n", ret );
1702             goto exit;
1703         }
1704     }
1705
1706     mbedtls_printf( " ok\n" );
1707
1708     ret = 0;
1709     goto exit;
1710
1711 exit:
1712
1713 #ifdef MBEDTLS_ERROR_C
1714     if( ret != 0 )
1715     {
1716         char error_buf[100];
1717         mbedtls_strerror( ret, error_buf, 100 );
1718         mbedtls_printf("Last error was: %d - %s\n\n", ret, error_buf );
1719     }
1720 #endif
1721
1722     mbedtls_net_free( &client_fd );
1723     mbedtls_net_free( &listen_fd );
1724
1725     mbedtls_x509_crt_free( &srvcert );
1726     mbedtls_pk_free( &pkey );
1727     mbedtls_ssl_free( &ssl );
1728     mbedtls_ssl_config_free( &conf );
1729 #if defined(MBEDTLS_SSL_CACHE_C)
1730     mbedtls_ssl_cache_free( &cache );
1731 #endif
1732     mbedtls_ctr_drbg_free( &ctr_drbg );
1733     mbedtls_entropy_free( &entropy );
1734
1735 #if defined(_WIN32)
1736     mbedtls_printf( "  Press Enter to exit this program.\n" );
1737     fflush( stdout );
1738 #endif
1739
1740     return NULL;
1741 }
1742 #endif /* MBEDTLS_BIGNUM_C && MBEDTLS_ENTROPY_C &&
1743           MBEDTLS_SSL_TLS_C && MBEDTLS_SSL_SRV_C && MBEDTLS_NET_C &&
1744           MBEDTLS_RSA_C && MBEDTLS_CTR_DRBG_C && MBEDTLS_X509_CRT_PARSE_C
1745           && MBEDTLS_FS_IO && MBEDTLS_PEM_PARSE_C */
1746
1747 /* **************************
1748  *
1749  *
1750  * CAinitSslAdapter test
1751  *
1752  *
1753  * *************************/
1754
1755 static int testCAinitSslAdapter()
1756 {
1757     int ret = 0;
1758     CAResult_t result = CA_STATUS_FAILED;
1759
1760     result = CAinitSslAdapter();
1761     if (result == CA_STATUS_OK)
1762     {
1763         CAdeinitSslAdapter();
1764     }
1765     else
1766     {
1767         ret = 1;
1768     }
1769
1770     return ret;
1771 }
1772
1773 // CAinitTlsAdapter()
1774 TEST(TLSAdapter, Test_1)
1775 {
1776     int ret = 0xFF;
1777     ret = testCAinitSslAdapter();
1778     EXPECT_EQ(0, ret);
1779 }
1780
1781 /* **************************
1782  *
1783  *
1784  * CAsetSslAdapterCallbacks test
1785  *
1786  *
1787  * *************************/
1788
1789 static int testCAsetSslAdapterCallbacks()
1790 {
1791     int ret = 0xFF;
1792     CAResult_t result = CA_STATUS_FAILED;
1793
1794     result = CAinitSslAdapter();
1795     if (result != CA_STATUS_OK)
1796     {
1797         return 1;
1798     }
1799
1800     CAsetSslAdapterCallbacks(CATCPPacketReceivedCB, CATCPPacketSendCB, (CATransportAdapter_t)0);
1801     if (g_caSslContext->adapterCallbacks[0].recvCallback == NULL &&
1802         g_caSslContext->adapterCallbacks[0].sendCallback == NULL &&
1803         g_caSslContext->adapterCallbacks[1].recvCallback == NULL &&
1804         g_caSslContext->adapterCallbacks[1].sendCallback == NULL)
1805     {
1806         ret = 0;
1807     }
1808     else
1809     {
1810         ret = 1;
1811     }
1812     CAsetSslAdapterCallbacks(CATCPPacketReceivedCB, CATCPPacketSendCB, CA_ADAPTER_IP);
1813     CAsetSslAdapterCallbacks(CATCPPacketReceivedCB, CATCPPacketSendCB, CA_ADAPTER_TCP);
1814     if (g_caSslContext->adapterCallbacks[0].recvCallback == CATCPPacketReceivedCB &&
1815         g_caSslContext->adapterCallbacks[0].sendCallback == CATCPPacketSendCB &&
1816         g_caSslContext->adapterCallbacks[1].recvCallback == CATCPPacketReceivedCB &&
1817         g_caSslContext->adapterCallbacks[1].sendCallback == CATCPPacketSendCB)
1818     {
1819         ret += 0;
1820     }
1821     else
1822     {
1823         ret += 1;
1824     }
1825
1826     CAdeinitSslAdapter();
1827
1828     return ret;
1829 }
1830
1831 // CAsetSslAdapterCallbacks()
1832 TEST(TLSAdapter, Test_2)
1833 {
1834     int ret = 0xFF;
1835     ret = testCAsetSslAdapterCallbacks();
1836     EXPECT_EQ(0, ret);
1837 }
1838
1839 /* **************************
1840  *
1841  *
1842  * CAinitiateSslHandshake test
1843  *
1844  *
1845  * *************************/
1846
1847 unsigned char predictedClientHello[] = {
1848     0x16, 0x03, 0x03, 0x00, 0x71, 0x01, 0x00, 0x00, 0x6d, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x34,
1849     0x1c, 0x45, 0xfa, 0xbf, 0x39, 0xe5, 0xbf, 0x52, 0x20, 0x4f, 0x8f, 0xf5, 0x6b, 0x89, 0xb0, 0xbb,
1850     0x3a, 0x5e, 0x13, 0xb4, 0x94, 0x73, 0xee, 0xf4, 0x98, 0x48, 0x4a, 0x00, 0x00, 0x14, 0xc0, 0xac,
1851     0x00, 0x3d, 0x00, 0x9c, 0xc0, 0x2b, 0xc0, 0xae, 0xc0, 0x23, 0xc0, 0x24, 0xc0, 0x2c, 0xc0, 0x27,
1852     0x00, 0xff, 0x01, 0x00, 0x00, 0x30, 0x00, 0x0d, 0x00, 0x16, 0x00, 0x14, 0x06, 0x03, 0x06, 0x01,
1853     0x05, 0x03, 0x05, 0x01, 0x04, 0x03, 0x04, 0x01, 0x03, 0x03, 0x03, 0x01, 0x02, 0x03, 0x02, 0x01,
1854     0x00, 0x0a, 0x00, 0x04, 0x00, 0x02, 0x00, 0x17, 0x00, 0x0b, 0x00, 0x02, 0x01, 0x00, 0x00, 0x16,
1855     0x00, 0x00, 0x00, 0x17, 0x00, 0x00
1856 };
1857 static unsigned char controlBuf[sizeof(predictedClientHello)];
1858 static size_t controlBufLen = 0;
1859 static ssize_t CATCPPacketSendCB_forInitHsTest(CAEndpoint_t *, const void * buf, size_t buflen)
1860 {
1861     int n;
1862     n = send(sockfd, (const char*)buf, (int)buflen, 0);
1863     if (n < 0)
1864     {
1865         error("ERROR writing to socket");
1866         return n;
1867     }
1868
1869     memset(controlBuf, 0, sizeof(predictedClientHello));
1870     memcpy(controlBuf, buf, buflen);
1871     controlBufLen = buflen;
1872     return buflen;
1873 }
1874
1875 static void * test0CAinitiateSslHandshake(void * arg)
1876 {
1877     CAEndpoint_t serverAddr;
1878     memset(&serverAddr, 0, sizeof(serverAddr));
1879     serverAddr.adapter = CA_ADAPTER_TCP;
1880     serverAddr.flags = CA_SECURE;
1881     serverAddr.port = 4433;
1882     char addr[] = {0x31, 0x32, 0x37, 0x2e, 0x30, 0x2e, 0x30, 0x2e, 0x31, 0x00}; // 127.0.0.1
1883     memcpy(serverAddr.addr, addr, sizeof(addr));
1884     serverAddr.ifindex = 0;
1885
1886     g_sslContextMutex = oc_mutex_new_recursive();
1887     oc_mutex_lock(g_sslContextMutex);
1888     g_caSslContext = (SslContext_t *)OICCalloc(1, sizeof(SslContext_t));
1889     g_caSslContext->peerList = u_arraylist_create();
1890     mbedtls_entropy_init(&g_caSslContext->entropy);
1891     mbedtls_ctr_drbg_init(&g_caSslContext->rnd);
1892     mbedtls_ctr_drbg_seed(&g_caSslContext->rnd, mbedtls_entropy_func_clutch,
1893                                   &g_caSslContext->entropy,
1894                                   (const unsigned char*) PERSONALIZATION_STRING, sizeof(PERSONALIZATION_STRING));
1895     mbedtls_ctr_drbg_set_prediction_resistance(&g_caSslContext->rnd, MBEDTLS_CTR_DRBG_PR_OFF);
1896     InitConfig(&g_caSslContext->clientTlsConf,
1897                         MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_IS_CLIENT);
1898     InitConfig(&g_caSslContext->serverTlsConf,
1899                         MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_IS_SERVER);
1900     mbedtls_ssl_cookie_init(&g_caSslContext->cookieCtx);
1901     mbedtls_ssl_cookie_setup(&g_caSslContext->cookieCtx, mbedtls_ctr_drbg_random,
1902                                       &g_caSslContext->rnd);
1903     InitConfig(&g_caSslContext->clientDtlsConf,
1904                         MBEDTLS_SSL_TRANSPORT_DATAGRAM, MBEDTLS_SSL_IS_CLIENT);
1905     InitConfig(&g_caSslContext->serverDtlsConf,
1906                         MBEDTLS_SSL_TRANSPORT_DATAGRAM, MBEDTLS_SSL_IS_SERVER);
1907     g_caSslContext->cipher = SSL_CIPHER_MAX;
1908     mbedtls_x509_crt_init(&g_caSslContext->ca);
1909     mbedtls_x509_crt_init(&g_caSslContext->crt);
1910     mbedtls_pk_init(&g_caSslContext->pkey);
1911     mbedtls_x509_crl_init(&g_caSslContext->crl);
1912     oc_mutex_unlock(g_sslContextMutex);
1913
1914     // CAsetSslAdapterCallbacks
1915     g_caSslContext->adapterCallbacks[1].recvCallback = CATCPPacketReceivedCB;
1916     g_caSslContext->adapterCallbacks[1].sendCallback = CATCPPacketSendCB_forInitHsTest;
1917
1918     // CAsetPkixInfoCallback
1919     g_getPkixInfoCallback = infoCallback_that_loads_x509;
1920
1921     // CAsetCredentialTypesCallback
1922     g_getCredentialTypesCallback = clutch;
1923
1924     // CAsetTlsCipherSuite
1925     mbedtls_ssl_conf_ciphersuites(&g_caSslContext->clientTlsConf,
1926                                          tlsCipher[SSL_ECDHE_ECDSA_WITH_AES_128_CCM]);
1927     mbedtls_ssl_conf_ciphersuites(&g_caSslContext->serverTlsConf,
1928                                          tlsCipher[SSL_ECDHE_ECDSA_WITH_AES_128_CCM]);
1929     g_caSslContext->cipher = SSL_ECDHE_ECDSA_WITH_AES_128_CCM;
1930
1931     CAsetPskCredentialsCallback(GetDtlsPskCredentials);
1932
1933     if (!socketConnect())
1934     {
1935         *((int*)arg) = 0xFF;
1936         return (void *) 0xFF;
1937     }
1938
1939     unsigned int unixTime = (unsigned)time(NULL);
1940     CAinitiateSslHandshake(&serverAddr);
1941     predictedClientHello[11] = unixTime >> 24;
1942     predictedClientHello[12] = (unixTime << 8) >> 24;
1943     predictedClientHello[13] = (unixTime << 16) >> 24;
1944     predictedClientHello[14] = (unixTime << 24) >> 24;
1945
1946     // CAcloseTlsConnection
1947     oc_mutex_lock(g_sslContextMutex);
1948     SslEndPoint_t * tep = GetSslPeer(&serverAddr);
1949     mbedtls_ssl_close_notify(&tep->ssl);
1950     RemovePeerFromList(&tep->sep.endpoint);
1951     oc_mutex_unlock(g_sslContextMutex);
1952
1953     // CAdeinitTlsAdapter
1954     oc_mutex_lock(g_sslContextMutex);
1955     DeletePeerList();
1956     mbedtls_x509_crt_free(&g_caSslContext->crt);
1957     mbedtls_pk_free(&g_caSslContext->pkey);
1958     mbedtls_ssl_config_free(&g_caSslContext->clientTlsConf);
1959     mbedtls_ssl_config_free(&g_caSslContext->serverTlsConf);
1960     mbedtls_ctr_drbg_free(&g_caSslContext->rnd);
1961     mbedtls_entropy_free(&g_caSslContext->entropy);
1962     OICFree(g_caSslContext);
1963     g_caSslContext = NULL;
1964     oc_mutex_unlock(g_sslContextMutex);
1965     oc_mutex_free(g_sslContextMutex);
1966     g_sslContextMutex = NULL;
1967
1968     socketClose();
1969
1970     if (controlBufLen == sizeof(predictedClientHello) &&
1971         memcmp(predictedClientHello, controlBuf, sizeof(predictedClientHello)) == 0)
1972     {
1973         *((int*)arg) = 0;
1974         return NULL;
1975     }
1976     else
1977     {
1978         *((int*)arg) = 0xFF;
1979         return (void *) 0xFF;
1980     }
1981 }
1982
1983 static int test1CAinitiateSslHandshake()
1984 {
1985     int ret = 0xff;
1986     ret = CAinitiateSslHandshake(NULL);
1987     if (CA_STATUS_INVALID_PARAM == ret)
1988     {
1989         ret = 0;
1990     }
1991     else
1992     {
1993         ret = 1;
1994     }
1995     return ret;
1996 }
1997
1998 // CAinitiateSslHandshake()
1999 // This test has a bug in it (IOT-1848):
2000 //  server() listens only on IPv6 on Windows (because IPV6_V6ONLY defaults
2001 //  to true) and socketConnect() is hard coded to try only IPv4.
2002 #ifdef HAVE_WINSOCK2_H
2003 TEST(TLSAdapter, DISABLED_Test_3_0)
2004 #else
2005 TEST(TLSAdapter, Test_3_0)
2006 #endif
2007 {
2008     socket_error = false;
2009     pthread_t thread1, thread2;
2010     int ret = 0;
2011     int arg = 1;
2012
2013     ret = pthread_create( &thread1, NULL, server, (void*) NULL);
2014     if(ret)
2015     {
2016         fprintf(stderr, "Error - pthread_create() return code: %d\n", ret);
2017         ASSERT_TRUE(false);
2018     }
2019
2020     sleep(5);
2021
2022     ret = pthread_create( &thread2, NULL, test0CAinitiateSslHandshake, &arg);
2023     if(ret)
2024     {
2025         fprintf(stderr, "Error - pthread_create() return code: %d\n", ret);
2026         ASSERT_TRUE(false);
2027     }
2028
2029     sleep(5);
2030
2031     ASSERT_FALSE(socket_error);
2032     EXPECT_EQ(0, arg);
2033 }
2034
2035 TEST(TLSAdapter, Test_3_1)
2036 {
2037     int ret = 0xFF;
2038     ret = test1CAinitiateSslHandshake();
2039     EXPECT_EQ(0, ret);
2040 }
2041
2042 /* **************************
2043  *
2044  *
2045  * CAencryptSsl test
2046  *
2047  *
2048  * *************************/
2049
2050 static void * testCAencryptSsl(void * arg)
2051 {
2052     int ret = 0;
2053     CAEndpoint_t serverAddr;
2054     memset(&serverAddr, 0, sizeof(serverAddr));
2055     serverAddr.adapter = CA_ADAPTER_TCP;
2056     serverAddr.flags = CA_SECURE;
2057     serverAddr.port = 4433;
2058     char addr[] = {0x31, 0x32, 0x37, 0x2e, 0x30, 0x2e, 0x30, 0x2e, 0x31, 0x00}; // 127.0.0.1
2059     memcpy(serverAddr.addr, addr, sizeof(addr));
2060     serverAddr.ifindex = 0;
2061
2062     CAinitSslAdapter();
2063
2064     CAsetSslAdapterCallbacks(CATCPPacketReceivedCB, CATCPPacketSendCB, CA_ADAPTER_TCP);
2065
2066     CAsetPkixInfoCallback(infoCallback_that_loads_x509);
2067
2068     // CAsetCredentialTypesCallback
2069     g_getCredentialTypesCallback = clutch;
2070
2071     if (*((int*)arg) == 0)
2072     {
2073         CAsetTlsCipherSuite(MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM);
2074     }
2075     else if (*((int*)arg) == 1)
2076     {
2077         CAsetTlsCipherSuite(MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8);
2078     }
2079     else if (*((int*)arg) == 2)
2080     {
2081         CAsetTlsCipherSuite(MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256);
2082     }
2083     else if (*((int*)arg) == 3)
2084     {
2085         CAsetTlsCipherSuite(MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256);
2086     }
2087     else if (*((int*)arg) == 4)
2088     {
2089         CAsetTlsCipherSuite(MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384);
2090     }
2091     else if (*((int*)arg) == 5)
2092     {
2093         CAsetTlsCipherSuite(MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384);
2094     }
2095
2096     CAsetPskCredentialsCallback(GetDtlsPskCredentials);
2097
2098     if (!socketConnect())
2099     {
2100         *((int*)arg) = 0xFF;
2101         return (void *) 0xFF;
2102     }
2103
2104     // CAinitiateSslHandshake
2105     CAinitiateSslHandshake(&serverAddr);
2106
2107     unsigned char buffer[2048] = {'\0'};
2108     int buflen = 0;
2109     CASecureEndpoint_t * sep = (CASecureEndpoint_t *) malloc (sizeof(CASecureEndpoint_t));
2110     sep->endpoint = serverAddr;
2111
2112     for (int i = 0; i < 6; i++)
2113     {
2114         PacketReceive(buffer, &buflen);
2115         if (buflen < 1)
2116         {
2117             *((int*)arg) = 0xFF;
2118             return (void *) 0xFF;
2119         }
2120         CAdecryptSsl(sep, (uint8_t *)buffer, buflen);
2121     }
2122
2123     ret = sprintf( (char*)buffer, GET_REQUEST );
2124
2125     CAencryptSsl(&serverAddr, buffer, ret);
2126
2127     PacketReceive(buffer, &buflen);
2128     if (buflen < 1)
2129     {
2130         *((int*)arg) = 0xFF;
2131         return (void *) 0xFF;
2132     }
2133     CAdecryptSsl(sep, (uint8_t *)buffer, buflen);
2134
2135     CAcloseSslConnection(&serverAddr);
2136
2137     CAdeinitSslAdapter();
2138
2139     socketClose();
2140
2141     if (*((int*)arg) == 0)
2142     {
2143         if (control_server_message_ECDHE_ECDSA_WITH_AES_128_CCM_len == msglen &&
2144             memcmp(msg, control_server_message_ECDHE_ECDSA_WITH_AES_128_CCM,
2145             control_server_message_ECDHE_ECDSA_WITH_AES_128_CCM_len) == 0)
2146         {
2147             ret = 0;
2148         }
2149         else
2150         {
2151             ret = 1;
2152         }
2153     }
2154     if (*((int*)arg) == 1)
2155     {
2156         if (control_server_message_ECDHE_ECDSA_WITH_AES_128_CCM_8_len == msglen &&
2157             memcmp(msg, control_server_message_ECDHE_ECDSA_WITH_AES_128_CCM_8,
2158             control_server_message_ECDHE_ECDSA_WITH_AES_128_CCM_8_len) == 0)
2159         {
2160             ret = 0;
2161         }
2162         else
2163         {
2164             ret = 1;
2165         }
2166     }
2167     else if (*((int*)arg) == 2)
2168     {
2169         if (control_server_message_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256_len == msglen &&
2170             memcmp(msg, control_server_message_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
2171             control_server_message_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256_len) == 0)
2172         {
2173             ret = 0;
2174         }
2175         else
2176         {
2177             ret = 1;
2178         }
2179     }
2180     else if (*((int*)arg) == 3)
2181     {
2182         if (control_server_message_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256_len == msglen &&
2183             memcmp(msg, control_server_message_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
2184             control_server_message_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256_len) == 0)
2185         {
2186             ret = 0;
2187         }
2188         else
2189         {
2190             ret = 1;
2191         }
2192     }
2193     else if (*((int*)arg) == 4)
2194     {
2195         if (control_server_message_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384_len == msglen &&
2196             memcmp(msg, control_server_message_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,
2197                    control_server_message_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384_len) == 0)
2198         {
2199             ret = 0;
2200         }
2201         else
2202         {
2203             ret = 1;
2204         }
2205     }
2206     else if (*((int*)arg) == 5)
2207     {
2208         if (control_server_message_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384_len == msglen &&
2209             memcmp(msg, control_server_message_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
2210                    control_server_message_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384_len) == 0)
2211         {
2212             ret = 0;
2213         }
2214         else
2215         {
2216             ret = 1;
2217         }
2218     }
2219
2220     if (ret == 0)
2221     {
2222         *((int*)arg) = 0;
2223         return NULL;
2224     }
2225     else
2226     {
2227         *((int*)arg) = 0xFF;
2228         return (void *) 0xFF;
2229     }
2230 }
2231
2232 // CAencryptSsl()
2233 // This test has a bug in it (IOT-1848):
2234 //  server() listens only on IPv6 on Windows (because IPV6_V6ONLY defaults
2235 //  to true) and socketConnect() is hard coded to try only IPv4.
2236 #ifdef HAVE_WINSOCK2_H
2237 TEST(TLSAdapter, DISABLED_Test_4_0)
2238 #else
2239 TEST(TLSAdapter, Test_4_0)
2240 #endif
2241 {
2242     socket_error = false;
2243     pthread_t thread1, thread2;
2244     int ret = 0;
2245     int arg = 0;
2246
2247     ret = pthread_create( &thread1, NULL, server, (void*) NULL);
2248     if(ret)
2249     {
2250         fprintf(stderr,"Error - pthread_create() return code: %d\n", ret);
2251         ASSERT_TRUE(false);
2252     }
2253
2254     sleep(5);
2255
2256     ret = pthread_create( &thread2, NULL, testCAencryptSsl, &arg);
2257     if(ret)
2258     {
2259         fprintf(stderr,"Error - pthread_create() return code: %d\n", ret);
2260         ASSERT_TRUE(false);
2261     }
2262
2263     sleep(5);
2264
2265     ASSERT_FALSE(socket_error);
2266     EXPECT_EQ(0, arg);
2267 }
2268
2269 // CAencryptSsl()
2270 // This test has a bug in it (IOT-1848):
2271 //  server() listens only on IPv6 on Windows (because IPV6_V6ONLY defaults
2272 //  to true) and socketConnect() is hard coded to try only IPv4.
2273 #ifdef HAVE_WINSOCK2_H
2274 TEST(TLSAdapter, DISABLED_Test_4_1)
2275 #else
2276 TEST(TLSAdapter, Test_4_1)
2277 #endif
2278 {
2279     socket_error = false;
2280     pthread_t thread1, thread2;
2281     int ret = 0;
2282     int arg = 1;
2283
2284     ret = pthread_create( &thread1, NULL, server, (void*) NULL);
2285     if(ret)
2286     {
2287         fprintf(stderr,"Error - pthread_create() return code: %d\n", ret);
2288         ASSERT_TRUE(false);
2289     }
2290
2291     sleep(5);
2292
2293     ret = pthread_create( &thread2, NULL, testCAencryptSsl, &arg);
2294     if(ret)
2295     {
2296         fprintf(stderr,"Error - pthread_create() return code: %d\n", ret);
2297         ASSERT_TRUE(false);
2298     }
2299
2300     sleep(5);
2301
2302     ASSERT_FALSE(socket_error);
2303     EXPECT_EQ(0, arg);
2304 }
2305
2306 // CAencryptSsl()
2307 // This test has a bug in it (IOT-1848):
2308 //  server() listens only on IPv6 on Windows (because IPV6_V6ONLY defaults
2309 //  to true) and socketConnect() is hard coded to try only IPv4.
2310 #ifdef HAVE_WINSOCK2_H
2311 TEST(TLSAdapter, DISABLED_Test_4_2)
2312 #else
2313 TEST(TLSAdapter, Test_4_2)
2314 #endif
2315 {
2316     socket_error = false;
2317     pthread_t thread1, thread2;
2318     int ret = 0;
2319     int arg = 2;
2320
2321     ret = pthread_create( &thread1, NULL, server, (void*) NULL);
2322     if(ret)
2323     {
2324         fprintf(stderr,"Error - pthread_create() return code: %d\n", ret);
2325         ASSERT_TRUE(false);
2326     }
2327
2328     sleep(5);
2329
2330     ret = pthread_create( &thread2, NULL, testCAencryptSsl, &arg);
2331     if(ret)
2332     {
2333         fprintf(stderr,"Error - pthread_create() return code: %d\n", ret);
2334         ASSERT_TRUE(false);
2335     }
2336
2337     sleep(5);
2338
2339     ASSERT_FALSE(socket_error);
2340     EXPECT_EQ(0, arg);
2341 }
2342
2343 // CAencryptSsl()
2344 // This test has a bug in it (IOT-1848):
2345 //  server() listens only on IPv6 on Windows (because IPV6_V6ONLY defaults
2346 //  to true) and socketConnect() is hard coded to try only IPv4.
2347 #ifdef HAVE_WINSOCK2_H
2348 TEST(TLSAdapter, DISABLED_Test_4_3)
2349 #else
2350 TEST(TLSAdapter, Test_4_3)
2351 #endif
2352 {
2353     socket_error = false;
2354     pthread_t thread1, thread2;
2355     int ret = 0;
2356     int arg = 3;
2357
2358     ret = pthread_create( &thread1, NULL, server, (void*) NULL);
2359     if(ret)
2360     {
2361         fprintf(stderr,"Error - pthread_create() return code: %d\n", ret);
2362         ASSERT_TRUE(false);
2363     }
2364
2365     sleep(5);
2366
2367     ret = pthread_create( &thread2, NULL, testCAencryptSsl, &arg);
2368     if(ret)
2369     {
2370         fprintf(stderr,"Error - pthread_create() return code: %d\n", ret);
2371         ASSERT_TRUE(false);
2372     }
2373
2374     sleep(5);
2375
2376     ASSERT_FALSE(socket_error);
2377     EXPECT_EQ(0, arg);
2378 }
2379
2380 // CAencryptSsl()
2381 // This test has a bug in it (IOT-1848):
2382 //  server() listens only on IPv6 on Windows (because IPV6_V6ONLY defaults
2383 //  to true) and socketConnect() is hard coded to try only IPv4.
2384 #ifdef HAVE_WINSOCK2_H
2385 TEST(TLSAdapter, DISABLED_Test_4_4)
2386 #else
2387 TEST(TLSAdapter, Test_4_4)
2388 #endif
2389 {
2390     socket_error = false;
2391     pthread_t thread1, thread2;
2392     int ret = 0;
2393     int arg = 4;
2394
2395     ret = pthread_create( &thread1, NULL, server, (void*) NULL);
2396     if(ret)
2397     {
2398         fprintf(stderr,"Error - pthread_create() return code: %d\n", ret);
2399         ASSERT_TRUE(false);
2400     }
2401
2402     sleep(5);
2403
2404     ret = pthread_create( &thread2, NULL, testCAencryptSsl, &arg);
2405     if(ret)
2406     {
2407         fprintf(stderr,"Error - pthread_create() return code: %d\n", ret);
2408         ASSERT_TRUE(false);
2409     }
2410
2411     sleep(5);
2412
2413     ASSERT_FALSE(socket_error);
2414     EXPECT_EQ(0, arg);
2415 }
2416
2417 // This test has a bug in it (IOT-1848):
2418 //  server() listens only on IPv6 on Windows (because IPV6_V6ONLY defaults
2419 //  to true) and socketConnect() is hard coded to try only IPv4.
2420 #ifdef HAVE_WINSOCK2_H
2421 TEST(TLSAdapter, DISABLED_Test_4_5)
2422 #else
2423 TEST(TLSAdapter, Test_4_5)
2424 #endif
2425 {
2426     socket_error = false;
2427     pthread_t thread1, thread2;
2428     int ret = 0;
2429     int arg = 5;
2430
2431     ret = pthread_create( &thread1, NULL, server, (void*) NULL);
2432     if(ret)
2433     {
2434         fprintf(stderr,"Error - pthread_create() return code: %d\n", ret);
2435         ASSERT_TRUE(false);
2436     }
2437
2438     sleep(5);
2439
2440     ret = pthread_create( &thread2, NULL, testCAencryptSsl, &arg);
2441     if(ret)
2442     {
2443         fprintf(stderr,"Error - pthread_create() return code: %d\n", ret);
2444         ASSERT_TRUE(false);
2445     }
2446
2447     sleep(5);
2448
2449     ASSERT_FALSE(socket_error);
2450     EXPECT_EQ(0, arg);
2451 }
2452
2453 /* **************************
2454  *
2455  *
2456  * CAdecryptSsl test
2457  *
2458  *
2459  * *************************/
2460
2461 static void * testCAdecryptSsl(void * arg)
2462 {
2463     int ret = 0;
2464     unsigned char buffer[2048] = {'\0'};
2465     int buflen = 0;
2466
2467     CAEndpoint_t serverAddr;
2468     memset(&serverAddr, 0, sizeof(serverAddr));
2469     serverAddr.adapter = CA_ADAPTER_TCP;
2470     serverAddr.flags = CA_SECURE;
2471     serverAddr.port = 4433;
2472     char addr[] = {0x31, 0x32, 0x37, 0x2e, 0x30, 0x2e, 0x30, 0x2e, 0x31, 0x00}; // 127.0.0.1
2473     memcpy(serverAddr.addr, addr, sizeof(addr));
2474     serverAddr.ifindex = 0;
2475
2476     CAinitSslAdapter();
2477
2478     CAsetSslAdapterCallbacks(CATCPPacketReceivedCB, CATCPPacketSendCB, CA_ADAPTER_TCP);
2479
2480     CAsetPkixInfoCallback(infoCallback_that_loads_x509);
2481
2482     CAsetCredentialTypesCallback(clutch);
2483
2484     CAsetTlsCipherSuite(MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM);
2485
2486     CAsetPskCredentialsCallback(GetDtlsPskCredentials);
2487
2488     if (!socketConnect())
2489     {
2490         *((int*)arg) = 0xFF;
2491         return (void *) 0xFF;
2492     }
2493
2494     // CAinitiateSslHandshake
2495     CAinitiateSslHandshake(&serverAddr);
2496
2497     CASecureEndpoint_t * sep = (CASecureEndpoint_t *) malloc (sizeof(CASecureEndpoint_t));
2498     sep->endpoint = serverAddr;
2499
2500     for (int i = 0; i < 6; i++)
2501     {
2502         PacketReceive(buffer, &buflen);
2503         if (buflen < 1)
2504         {
2505             *((int*)arg) = 0xFF;
2506             return (void *) 0xFF;
2507         }
2508         CAdecryptSsl(sep, (uint8_t *)buffer, buflen);
2509     }
2510
2511     ret = sprintf((char*)buffer, GET_REQUEST);
2512
2513     CAencryptSsl(&serverAddr, buffer, ret);
2514
2515     PacketReceive(buffer, &buflen);
2516     if (buflen < 1)
2517     {
2518         *((int*)arg) = 0xFF;
2519         return (void *) 0xFF;
2520     }
2521     CAdecryptSsl(sep, (uint8_t *)buffer, buflen);
2522
2523     CAcloseSslConnection(&serverAddr);
2524
2525     CAdeinitSslAdapter();
2526
2527     socketClose();
2528
2529     if (control_server_message_ECDHE_ECDSA_WITH_AES_128_CCM_len == msglen &&
2530             memcmp(msg, control_server_message_ECDHE_ECDSA_WITH_AES_128_CCM,
2531             control_server_message_ECDHE_ECDSA_WITH_AES_128_CCM_len) == 0)
2532     {
2533         *((int*)arg) = 0;
2534         return NULL;
2535     }
2536     else
2537     {
2538         *((int*)arg) = 0xFF;
2539         return (void *) 0xFF;
2540     }
2541 }
2542
2543 // CAdecryptTls()
2544 // This test has a bug in it (IOT-1848):
2545 //  server() listens only on IPv6 on Windows (because IPV6_V6ONLY defaults
2546 //  to true) and socketConnect() is hard coded to try only IPv4.
2547 #ifdef HAVE_WINSOCK2_H
2548 TEST(TLSAdapter, DISABLED_Test_5)
2549 #else
2550 TEST(TLSAdapter, Test_5)
2551 #endif
2552 {
2553     socket_error = false;
2554     pthread_t thread1, thread2;
2555     int ret = 0;
2556     int arg = 1;
2557
2558     ret = pthread_create( &thread1, NULL, server, (void*) NULL);
2559     if(ret)
2560     {
2561         fprintf(stderr,"Error - pthread_create() return code: %d\n", ret);
2562         ASSERT_TRUE(false);
2563     }
2564
2565     sleep(5);
2566
2567     ret = pthread_create( &thread2, NULL, testCAdecryptSsl, &arg);
2568     if(ret)
2569     {
2570         fprintf(stderr,"Error - pthread_create() return code: %d\n", ret);
2571         ASSERT_TRUE(false);
2572     }
2573
2574     sleep(5);
2575
2576     ASSERT_FALSE(socket_error);
2577     EXPECT_EQ(0, arg);
2578 }
2579
2580 /* **************************
2581  *
2582  *
2583  * CAdeinitSslAdapter test
2584  *
2585  *
2586  * *************************/
2587
2588 static int testCAdeinitSslAdapter()
2589 {
2590     int ret = 0;
2591     CAEndpoint_t serverAddr;
2592     serverAddr.adapter = CA_ADAPTER_IP;
2593     serverAddr.flags = CA_SECURE;
2594     serverAddr.port = 4433;
2595     char addr[] = {0x31, 0x32, 0x37, 0x2e, 0x30, 0x2e, 0x30, 0x2e, 0x31, 0x00}; // 127.0.0.1
2596     memcpy(serverAddr.addr, addr, sizeof(addr));
2597     serverAddr.ifindex = 0;
2598
2599     CAinitSslAdapter();
2600
2601     CAsetSslAdapterCallbacks(CATCPPacketReceivedCB, CATCPPacketSendCB, CA_ADAPTER_TCP);
2602
2603     CAsetPkixInfoCallback(infoCallback_that_loads_x509);
2604
2605     CAsetTlsCipherSuite(SSL_ECDHE_ECDSA_WITH_AES_128_CCM);
2606
2607     CAdeinitSslAdapter();
2608
2609     if (g_caSslContext != NULL ||
2610         g_sslContextMutex != NULL)
2611     {
2612         ret = 1;
2613     }
2614     else
2615     {
2616         ret = 0;
2617     }
2618     return ret;
2619 }
2620
2621 // CAdeinitSslAdapter()
2622 TEST(TLSAdapter, Test_6)
2623 {
2624     int ret = 0xFF;
2625     ret = testCAdeinitSslAdapter();
2626     EXPECT_EQ(0, ret);
2627 }
2628
2629 /* **************************
2630  *
2631  *
2632  * Server side test
2633  *
2634  *
2635  * *************************/
2636
2637 static void * testServer(void * arg)
2638 {
2639     CAEndpoint_t serverAddr;
2640     serverAddr.adapter = CA_ADAPTER_TCP;
2641     serverAddr.flags = CA_SECURE;
2642     serverAddr.port = 4432;
2643     char addr[] = {0x31, 0x32, 0x37, 0x2e, 0x30, 0x2e, 0x30, 0x2e, 0x31, 0x00}; // 127.0.0.1
2644     memcpy(serverAddr.addr, addr, sizeof(addr));
2645     serverAddr.ifindex = 0;
2646     unsigned char buffer[2048] = {'\0'};
2647     int buflen = 0;
2648
2649     CAinitSslAdapter();
2650
2651     CAsetSslAdapterCallbacks(CATCPPacketReceivedCB_server, CATCPPacketSendCB_server, CA_ADAPTER_TCP);
2652     CAsetPkixInfoCallback(infoCallback_that_loads_x509);
2653
2654     CAsetCredentialTypesCallback(clutch);
2655
2656     CAsetTlsCipherSuite(MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM);
2657
2658     CAsetPskCredentialsCallback(GetDtlsPskCredentials);
2659
2660     if (!socketOpen_server())
2661     {
2662         *((int*)arg) = 0xFF;
2663         return (void *) 0xFF;
2664     }
2665
2666     CASecureEndpoint_t * sep = (CASecureEndpoint_t *) malloc (sizeof(CASecureEndpoint_t));
2667     sep->endpoint = serverAddr;
2668
2669     for (int i = 0; i < 7; i++)
2670     {
2671         PacketReceive_server(buffer, &buflen);
2672         if (buflen < 1)
2673         {
2674             *((int*)arg) = 0xFF;
2675             return (void *) 0xFF;
2676         }
2677         CAdecryptSsl(sep, (uint8_t *)buffer, buflen);
2678     }
2679
2680     CAcloseSslConnection(&serverAddr);
2681
2682     CAdeinitSslAdapter();
2683
2684     socketClose_server();
2685
2686     if (control_client_message_len == msglen && memcmp(msg, control_client_message,
2687                                                             control_client_message_len) == 0)
2688     {
2689         *((int*)arg) = 0;
2690         return NULL;
2691     }
2692     else
2693     {
2694         *((int*)arg) = 0xFF;
2695         return (void *) 0xFF;
2696     }
2697 }
2698
2699 #ifdef HAVE_WINSOCK2_H
2700 // This test doesn't work on Windows:
2701 // testServer opens a socket without first calling WSAStartup
2702 // PacketReceive_server calls read() rather than recv() on a socket handle
2703 TEST(TLSAdapter, DISABLED_Test_7)
2704 #else
2705 TEST(TLSAdapter, Test_7)
2706 #endif
2707 {
2708     socket_error = false;
2709     pthread_t thread1, thread2;
2710     int ret = 0;
2711     int arg = 1;
2712
2713     ret = pthread_create( &thread1, NULL, testServer, &arg);
2714     if (ret)
2715     {
2716         fprintf(stderr,"Error - pthread_create() return code: %d\n", ret);
2717         ASSERT_TRUE(false);
2718     }
2719
2720     sleep(5);
2721
2722     ret = pthread_create( &thread2, NULL, client, (void*) NULL);
2723     if (ret)
2724     {
2725         fprintf(stderr,"Error - pthread_create() return code: %d\n", ret);
2726         ASSERT_TRUE(false);
2727     }
2728
2729     sleep(5);
2730
2731     ASSERT_FALSE(socket_error);
2732     EXPECT_EQ(0, arg);
2733 }
2734
2735 /* **************************
2736  *
2737  * CAsetPskCredentialsCallback test
2738  * CAsetPkixInfoCallback test
2739  * CAsetCredentialTypesCallback test
2740  *
2741  * *************************/
2742
2743 static int testCAsetPskCredentialsCallback()
2744 {
2745     static CAgetPskCredentialsHandler credCallback = (CAgetPskCredentialsHandler)dummyHandler;
2746     CAsetPskCredentialsCallback(credCallback);
2747     if (g_getCredentialsCallback == (CAgetPskCredentialsHandler)dummyHandler)
2748     {
2749         return 0;
2750     }
2751     else
2752     {
2753         return 1;
2754     }
2755 }
2756
2757 static int testCAsetPkixInfoCallback()
2758 {
2759     static CAgetPkixInfoHandler infoCallback = (CAgetPkixInfoHandler)dummyHandler;
2760     CAsetPkixInfoCallback(infoCallback);
2761     if (g_getPkixInfoCallback == (CAgetPkixInfoHandler)dummyHandler)
2762     {
2763         return 0;
2764     }
2765     else
2766     {
2767         return 1;
2768     }
2769 }
2770
2771 static int testCAsetCredentialTypesCallback()
2772 {
2773     static CAgetCredentialTypesHandler credTypesCallback = (CAgetCredentialTypesHandler)dummyHandler;
2774     CAsetCredentialTypesCallback(credTypesCallback);
2775     if (g_getCredentialTypesCallback == (CAgetCredentialTypesHandler)dummyHandler)
2776     {
2777         return 0;
2778     }
2779     else
2780     {
2781         return 1;
2782     }
2783 }
2784
2785 // CAsetPskCredentialsCallback()
2786 TEST(TLSAdapter, Test_9_0)
2787 {
2788     int ret = 0xFF;
2789     ret = testCAsetPskCredentialsCallback();
2790     EXPECT_EQ(0, ret);
2791 }
2792 // CAsetPkixInfoCallback()
2793 TEST(TLSAdapter, Test_9_1)
2794 {
2795     int ret = 0xFF;
2796     ret = testCAsetPkixInfoCallback();
2797     EXPECT_EQ(0, ret);
2798 }
2799 // CAsetCredentialTypesCallback()
2800 TEST(TLSAdapter, Test_9_2)
2801 {
2802     int ret = 0xFF;
2803     ret = testCAsetCredentialTypesCallback();
2804     EXPECT_EQ(0, ret);
2805 }
2806
2807 /* **************************
2808  *
2809  *
2810  * CAsetTlsCipherSuite test
2811  *
2812  *
2813  * *************************/
2814
2815 static int testCAsetTlsCipherSuite()
2816 {
2817     int ret = 0, status = 0;
2818     CAEndpoint_t serverAddr;
2819     serverAddr.adapter = CA_ADAPTER_TCP;
2820     serverAddr.flags = CA_SECURE;
2821     serverAddr.port = 4433;
2822     char addr[] = {0x31, 0x32, 0x37, 0x2e, 0x30, 0x2e, 0x30, 0x2e, 0x31, 0x00}; // 127.0.0.1
2823     memcpy(serverAddr.addr, addr, sizeof(addr));
2824     serverAddr.ifindex = 0;
2825
2826     CAinitSslAdapter();
2827
2828     CAsetCredentialTypesCallback(clutch);
2829
2830     status = CAsetTlsCipherSuite(MBEDTLS_TLS_RSA_WITH_AES_256_CBC_SHA256);
2831     if (SSL_RSA_WITH_AES_256_CBC_SHA256 != g_caSslContext->cipher || status != CA_STATUS_OK)
2832     {
2833         ret += 1;
2834     }
2835
2836     status = CAsetTlsCipherSuite(MBEDTLS_TLS_RSA_WITH_AES_128_GCM_SHA256);
2837     if (SSL_RSA_WITH_AES_128_GCM_SHA256 != g_caSslContext->cipher || status != CA_STATUS_OK)
2838     {
2839         ret += 1;
2840     }
2841
2842     status = CAsetTlsCipherSuite(MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256);
2843     if (SSL_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 != g_caSslContext->cipher || status != CA_STATUS_OK)
2844     {
2845         ret += 1;
2846     }
2847     status = CAsetTlsCipherSuite(MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8);
2848     if (SSL_ECDHE_ECDSA_WITH_AES_128_CCM_8 != g_caSslContext->cipher || status != CA_STATUS_OK)
2849     {
2850         ret += 1;
2851     }
2852
2853     status = CAsetTlsCipherSuite(MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CCM);
2854     if (SSL_ECDHE_ECDSA_WITH_AES_128_CCM != g_caSslContext->cipher || status != CA_STATUS_OK)
2855     {
2856         ret += 1;
2857     }
2858
2859     status = CAsetTlsCipherSuite(MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256);
2860     if (SSL_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 != g_caSslContext->cipher || status != CA_STATUS_OK)
2861     {
2862         ret += 1;
2863     }
2864
2865     status = CAsetTlsCipherSuite(MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384);
2866     if (SSL_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 != g_caSslContext->cipher || status != CA_STATUS_OK)
2867     {
2868         ret += 1;
2869     }
2870
2871     status = CAsetTlsCipherSuite(MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384);
2872     if (SSL_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 != g_caSslContext->cipher || status != CA_STATUS_OK)
2873     {
2874         ret += 1;
2875     }
2876
2877     status = CAsetTlsCipherSuite(MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256);
2878     if (SSL_ECDHE_PSK_WITH_AES_128_CBC_SHA256 != g_caSslContext->cipher || status != CA_STATUS_OK)
2879     {
2880         ret += 1;
2881     }
2882
2883     status = CAsetTlsCipherSuite(MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256);
2884     if (SSL_ECDHE_RSA_WITH_AES_128_CBC_SHA256 != g_caSslContext->cipher || status != CA_STATUS_OK)
2885     {
2886         ret += 1;
2887     }
2888
2889     status = CAsetTlsCipherSuite(MBEDTLS_TLS_ECDH_ANON_WITH_AES_128_CBC_SHA256);
2890     if (SSL_ECDH_ANON_WITH_AES_128_CBC_SHA256 != g_caSslContext->cipher || status != CA_STATUS_OK)
2891     {
2892         ret += 1;
2893     }
2894
2895     CAdeinitSslAdapter();
2896
2897     return ret;
2898 }
2899
2900 // CAinitTlsAdapter()
2901 TEST(TLSAdapter, Test_10)
2902 {
2903     int ret = 0xff;
2904     ret = testCAsetTlsCipherSuite();
2905     EXPECT_EQ(0, ret);
2906 }
2907
2908 // This test has a bug in it (IOT-1848):
2909 //  server() listens only on IPv6 on Windows (because IPV6_V6ONLY defaults
2910 //  to true) and socketConnect() is hard coded to try only IPv4.
2911 #ifdef HAVE_WINSOCK2_H
2912 TEST(TLSAdapter, DISABLED_Test_11)
2913 #else
2914 TEST(TLSAdapter, Test_11)
2915 #endif
2916 {
2917     uint8_t predictedPSK[] = {
2918         0xba, 0x72, 0x16, 0xbc, 0x7f, 0x8c, 0xfe, 0xfc, 0xd0, 0xac, 0x1a, 0x37, 0xad, 0x60, 0xe8, 0x9e, 
2919         0xb3, 0x31, 0xa2, 0x30, 0xaf, 0x68, 0xc9, 0xa6, 0x89, 0x8a, 0x04, 0x21, 0x6c, 0xbd, 0x04, 0x08, 
2920         0x68, 0x11, 0x54, 0x9e, 0x2a, 0x10, 0x91, 0x94, 0x3c, 0x44, 0x52, 0xc7, 0xfa, 0x78, 0x44, 0x87, 
2921         0xea, 0x30, 0x08, 0x5f, 0xc1, 0x64, 0xaa, 0x0d, 0xfd, 0x84, 0x16, 0x83, 0x20, 0xc9, 0x08, 0x65, 
2922         0xd2, 0x4a, 0x55, 0x9e, 0x8f, 0x88, 0x3c, 0x57, 0x10, 0xbd, 0x5a, 0x30, 0x01, 0xb4, 0x59, 0x63, 
2923         0x64, 0x19, 0x8d, 0xfa, 0x5c, 0x86, 0x92, 0xf7, 0x60, 0x99, 0xdb, 0xae, 0x0e, 0xad, 0x80, 0xf1, 
2924         0x82, 0xaf, 0x1b, 0x14
2925     };
2926     size_t predictedPSK_len = sizeof(predictedPSK);
2927
2928     uint8_t label[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A};
2929     uint8_t rsrcServerDeviceId[] = {0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A};
2930     uint8_t provServerDeviceId[] = {0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A};
2931     uint8_t *ownerPsk = (uint8_t*)OICMalloc(predictedPSK_len);
2932     EXPECT_TRUE(NULL != ownerPsk) << "Cannot allocate memory";
2933     memset(ownerPsk, 0, predictedPSK_len);
2934
2935     socket_error = false;
2936
2937     CAEndpoint_t serverAddr;
2938     memset(&serverAddr, 0, sizeof(serverAddr));
2939     serverAddr.adapter = CA_ADAPTER_TCP;
2940     serverAddr.flags = CA_SECURE;
2941     serverAddr.port = 4433;
2942     char addr[] = {0x31, 0x32, 0x37, 0x2e, 0x30, 0x2e, 0x30, 0x2e, 0x31, 0x00}; // 127.0.0.1
2943     memcpy(serverAddr.addr, addr, sizeof(addr));
2944     serverAddr.ifindex = 0;
2945
2946     //start server
2947     pthread_t thread;
2948     EXPECT_EQ(0, pthread_create( &thread, NULL, server, (void*) NULL)) << "Thread create";
2949     sleep(5);
2950     ASSERT_FALSE(socket_error) << "Server: socket error";
2951
2952     g_sslContextMutex = oc_mutex_new_recursive();
2953     oc_mutex_lock(g_sslContextMutex);
2954     g_caSslContext = (SslContext_t *)OICCalloc(1, sizeof(SslContext_t));
2955     g_caSslContext->peerList = u_arraylist_create();
2956     mbedtls_entropy_init(&g_caSslContext->entropy);
2957     mbedtls_ctr_drbg_init(&g_caSslContext->rnd);
2958     mbedtls_ctr_drbg_seed(&g_caSslContext->rnd, mbedtls_entropy_func_clutch,
2959                                   &g_caSslContext->entropy,
2960                                   (const unsigned char*) PERSONALIZATION_STRING, sizeof(PERSONALIZATION_STRING));
2961     mbedtls_ctr_drbg_set_prediction_resistance(&g_caSslContext->rnd, MBEDTLS_CTR_DRBG_PR_OFF);
2962     InitConfig(&g_caSslContext->clientTlsConf,
2963                         MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_IS_CLIENT);
2964     InitConfig(&g_caSslContext->serverTlsConf,
2965                         MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_IS_SERVER);
2966     mbedtls_ssl_cookie_init(&g_caSslContext->cookieCtx);
2967     mbedtls_ssl_cookie_setup(&g_caSslContext->cookieCtx, mbedtls_ctr_drbg_random,
2968                                       &g_caSslContext->rnd);
2969     InitConfig(&g_caSslContext->clientDtlsConf,
2970                         MBEDTLS_SSL_TRANSPORT_DATAGRAM, MBEDTLS_SSL_IS_CLIENT);
2971     InitConfig(&g_caSslContext->serverDtlsConf,
2972                         MBEDTLS_SSL_TRANSPORT_DATAGRAM, MBEDTLS_SSL_IS_SERVER);
2973     g_caSslContext->cipher = SSL_CIPHER_MAX;
2974     mbedtls_x509_crt_init(&g_caSslContext->ca);
2975     mbedtls_x509_crt_init(&g_caSslContext->crt);
2976     mbedtls_pk_init(&g_caSslContext->pkey);
2977     mbedtls_x509_crl_init(&g_caSslContext->crl);
2978     oc_mutex_unlock(g_sslContextMutex);
2979
2980     CAsetSslAdapterCallbacks(CATCPPacketReceivedCB, CATCPPacketSendCB, CA_ADAPTER_TCP);
2981
2982     CAsetPkixInfoCallback(infoCallback_that_loads_x509);
2983
2984     CAsetCredentialTypesCallback(clutch);
2985
2986     CAsetTlsCipherSuite(MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256);
2987     g_caSslContext->selectedCipher = MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256;
2988
2989     CAsetPskCredentialsCallback(GetDtlsPskCredentials);
2990
2991     EXPECT_NE(false, socketConnect());
2992     ASSERT_FALSE(socket_error) << "Client: cannot connect to server";
2993
2994     // CAinitiateSslHandshake
2995     oc_mutex_lock(g_sslContextMutex);
2996     InitiateTlsHandshake(&serverAddr);
2997     oc_mutex_unlock(g_sslContextMutex);
2998
2999     EXPECT_EQ(0, CAsslGenerateOwnerPsk(&serverAddr,
3000           label, sizeof(label),
3001           rsrcServerDeviceId, sizeof(rsrcServerDeviceId),
3002           provServerDeviceId, sizeof(provServerDeviceId),
3003           ownerPsk, predictedPSK_len));
3004
3005     CAcloseSslConnection(&serverAddr);
3006
3007     CAdeinitSslAdapter();
3008
3009     socketClose();
3010
3011     ASSERT_FALSE(socket_error) << "Client: socket error";
3012
3013     mbedtls_printf("Got PSK:\n");
3014     printHexArray(ownerPsk, predictedPSK_len, DEFAULT_HEX_WIDTH);
3015     EXPECT_EQ(0, memcmp(predictedPSK, ownerPsk, predictedPSK_len)) << "PSK error";
3016     OICFree(ownerPsk);
3017 }
3018
3019 TEST(TLSAdapter, Test_ParseChain)
3020 {
3021     int errNum;
3022     mbedtls_x509_crt crt;
3023     mbedtls_x509_crt_init(&crt);
3024     size_t ret = ParseChain(&crt, certChain, certChainLen, &errNum);
3025     mbedtls_x509_crt_free(&crt);
3026
3027     EXPECT_EQ(7u, ret);
3028     EXPECT_EQ(0, errNum);
3029 }
3030
3031 TEST(TLSAdapter, TestCertsValid)
3032 {
3033     mbedtls_x509_crt cert;
3034
3035     mbedtls_x509_crt_init(&cert);
3036     int ret = mbedtls_x509_crt_parse(&cert, (const unsigned char *)serverCert, serverCertLen);
3037     EXPECT_EQ(0, ret) << "Failed to parse server cert";
3038     mbedtls_x509_crt_free(&cert);
3039
3040     mbedtls_x509_crt_init(&cert);
3041     ret = mbedtls_x509_crt_parse(&cert, (const unsigned char *)caCert, caCertLen);
3042     EXPECT_EQ(0, ret) << "Failed to parse CA cert";
3043     mbedtls_x509_crt_free(&cert);
3044 }