Debian Codegraph @

src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters/tlsio_schannel.c

raw
1 // Copyright (c) Microsoft. All rights reserved.
2 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
3
4 #define SECURITY_WIN32
5 #define SEC_TCHAR SEC_CHAR
6
7 #include <stdlib.h>
8 #include <stdio.h>
9 #include <stdbool.h>
10 #include "azure_macro_utils/macro_utils.h"
11 #include "azure_c_shared_utility/tlsio.h"
12 #include "azure_c_shared_utility/tlsio_schannel.h"
13 #include "azure_c_shared_utility/socketio.h"
14 #include "windows.h"
15 #include "sspi.h"
16 #include "schannel.h"
17 #include "azure_c_shared_utility/optimize_size.h"
18 #include "azure_c_shared_utility/xlogging.h"
19 #include "azure_c_shared_utility/x509_schannel.h"
20 #include "azure_c_shared_utility/crt_abstractions.h"
21 #include "azure_c_shared_utility/singlylinkedlist.h"
22 #include "azure_c_shared_utility/shared_util_options.h"
23 #include "azure_c_shared_utility/gballoc.h"
24 #include "azure_c_shared_utility/safe_math.h"
25
26 #define TLSIO_STATE_VALUES \
27 TLSIO_STATE_NOT_OPEN, \
28 TLSIO_STATE_OPENING_UNDERLYING_IO, \
29 TLSIO_STATE_HANDSHAKE_CLIENT_HELLO_SENT, \
30 TLSIO_STATE_HANDSHAKE_SERVER_HELLO_RECEIVED, \
31 TLSIO_STATE_RENEGOTIATE, \
32 TLSIO_STATE_OPEN, \
33 TLSIO_STATE_CLOSING, \
34 TLSIO_STATE_ERROR
35
36 MU_DEFINE_ENUM(TLSIO_STATE, TLSIO_STATE_VALUES);
37 MU_DEFINE_ENUM_STRINGS(TLSIO_STATE, TLSIO_STATE_VALUES);
38
39 typedef struct PENDING_SEND_TAG
40 {
41 unsigned char* bytes;
42 size_t length;
43 ON_SEND_COMPLETE on_send_complete;
44 void* on_send_complete_context;
45 } PENDING_SEND;
46
47 typedef struct TLS_IO_INSTANCE_TAG
48 {
49 XIO_HANDLE socket_io;
50 ON_IO_OPEN_COMPLETE on_io_open_complete;
51 ON_IO_CLOSE_COMPLETE on_io_close_complete;
52 ON_BYTES_RECEIVED on_bytes_received;
53 ON_IO_ERROR on_io_error;
54 void* on_io_open_complete_context;
55 void* on_io_close_complete_context;
56 void* on_bytes_received_context;
57 void* on_io_error_context;
58 CtxtHandle security_context;
59 TLSIO_STATE tlsio_state;
60 SEC_TCHAR* host_name;
61 CredHandle credential_handle;
62 bool credential_handle_allocated;
63 bool ignore_server_name_check;
64 unsigned char* received_bytes;
65 size_t received_byte_count;
66 size_t buffer_size;
67 size_t needed_bytes;
68 char* x509certificate;
69 char* x509privatekey;
70 X509_SCHANNEL_HANDLE x509_schannel_handle;
71 SINGLYLINKEDLIST_HANDLE pending_io_list;
72 // Certificate to check server certificate chains to, overriding built-in Windows certificate store certificates.
73 char* trustedCertificate;
74 } TLS_IO_INSTANCE;
75
76 /*this function will clone an option given by name and value*/
77 static void* tlsio_schannel_CloneOption(const char* name, const void* value)
78 {
79 void* result;
80 if (
81 (name == NULL) || (value == NULL)
82 )
83 {
84 LogError("invalid parameter detected: const char* name = %p, const void* value = %p", name, value);
85 result = NULL;
86 }
87 else
88 {
89 if (strcmp(name, SU_OPTION_X509_CERT) == 0 || strcmp(name, OPTION_X509_ECC_CERT) == 0)
90 {
91 if (mallocAndStrcpy_s((char**)&result, (const char *) value) != 0)
92 {
93 LogError("unable to mallocAndStrcpy_s x509certificate value");
94 result = NULL;
95 }
96 else
97 {
98 /*return as is*/
99 }
100 }
101 else if (strcmp(name, SU_OPTION_X509_PRIVATE_KEY) == 0 || strcmp(name, OPTION_X509_ECC_KEY) == 0)
102 {
103 if (mallocAndStrcpy_s((char**)&result, (const char *) value) != 0)
104 {
105 LogError("unable to mallocAndStrcpy_s x509privatekey value");
106 result = NULL;
107 }
108 else
109 {
110 /*return as is*/
111 }
112 }
113 else if (strcmp(name, OPTION_TRUSTED_CERT) == 0)
114 {
115 if (mallocAndStrcpy_s((char**)&result, (const char *) value) != 0)
116 {
117 LogError("unable to mallocAndStrcpy_s TrustedCerts value");
118 result = NULL;
119 }
120 else
121 {
122 /*return as is*/
123 }
124 }
125 else
126 {
127 LogError("not handled option : %s", name);
128 result = NULL;
129 }
130 }
131 return result;
132 }
133
134 /*this function destroys an option previously created*/
135 static void tlsio_schannel_DestroyOption(const char* name, const void* value)
136 {
137 /*since all options for this layer are actually string copies., disposing of one is just calling free*/
138 if (
139 (name == NULL) || (value == NULL)
140 )
141 {
142 LogError("invalid parameter detected: const char* name = %p, const void* value = %p", name, value);
143 }
144 else
145 {
146 if (
147 (strcmp(name, SU_OPTION_X509_CERT) == 0) ||
148 (strcmp(name, SU_OPTION_X509_PRIVATE_KEY) == 0) ||
149 (strcmp(name, OPTION_X509_ECC_CERT) == 0) ||
150 (strcmp(name, OPTION_X509_ECC_KEY) == 0) ||
151 (strcmp(name, OPTION_TRUSTED_CERT) == 0)
152 )
153 {
154 free((void*)value);
155 }
156 else
157 {
158 LogError("not handled option : %s", name);
159 }
160 }
161 }
162
163 static OPTIONHANDLER_HANDLE tlsio_schannel_retrieveoptions(CONCRETE_IO_HANDLE handle)
164 {
165 OPTIONHANDLER_HANDLE result;
166 if (handle == NULL)
167 {
168 LogError("invalid parameter detected: CONCRETE_IO_HANDLE handle = %p", handle);
169 result = NULL;
170 }
171 else
172 {
173 result = OptionHandler_Create(tlsio_schannel_CloneOption, tlsio_schannel_DestroyOption, tlsio_schannel_setoption);
174 if (result == NULL)
175 {
176 LogError("unable to OptionHandler_Create");
177 /*return as is*/
178 }
179 else
180 {
181 /*this layer cares about the certificates and the x509 credentials*/
182 TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)handle;
183 if (
184 (tls_io_instance->x509certificate != NULL) &&
185 (OptionHandler_AddOption(result, "x509certificate", tls_io_instance->x509certificate) != OPTIONHANDLER_OK)
186 )
187 {
188 LogError("unable to save x509certificate option");
189 OptionHandler_Destroy(result);
190 result = NULL;
191 }
192 else if (
193 (tls_io_instance->trustedCertificate != NULL) &&
194 (OptionHandler_AddOption(result, OPTION_TRUSTED_CERT, tls_io_instance->trustedCertificate) != OPTIONHANDLER_OK)
195 )
196 {
197 LogError("unable to save TrustedCerts option");
198 OptionHandler_Destroy(result);
199 result = NULL;
200 }
201 else if (
202 (tls_io_instance->x509privatekey != NULL) &&
203 (OptionHandler_AddOption(result, "x509privatekey", tls_io_instance->x509privatekey) != OPTIONHANDLER_OK)
204 )
205 {
206 LogError("unable to save x509privatekey option");
207 OptionHandler_Destroy(result);
208 result = NULL;
209 }
210 else
211 {
212 /*all is fine, all interesting options have been saved*/
213 /*return as is*/
214 }
215 }
216 }
217 return result;
218 }
219
220 static const IO_INTERFACE_DESCRIPTION tlsio_schannel_interface_description =
221 {
222 tlsio_schannel_retrieveoptions,
223 tlsio_schannel_create,
224 tlsio_schannel_destroy,
225 tlsio_schannel_open,
226 tlsio_schannel_close,
227 tlsio_schannel_send,
228 tlsio_schannel_dowork,
229 tlsio_schannel_setoption
230 };
231
232 static void indicate_error(TLS_IO_INSTANCE* tls_io_instance)
233 {
234 if (tls_io_instance->on_io_error != NULL)
235 {
236 tls_io_instance->on_io_error(tls_io_instance->on_io_error_context);
237 }
238 }
239
240 static int resize_receive_buffer(TLS_IO_INSTANCE* tls_io_instance, size_t needed_buffer_size)
241 {
242 int result;
243
244 if (needed_buffer_size > tls_io_instance->buffer_size)
245 {
246 unsigned char* new_buffer = (unsigned char*) realloc(tls_io_instance->received_bytes, needed_buffer_size);
247 if (new_buffer == NULL)
248 {
249 LogError("realloc failed");
250 result = MU_FAILURE;
251 }
252 else
253 {
254 tls_io_instance->received_bytes = new_buffer;
255 tls_io_instance->buffer_size = needed_buffer_size;
256 result = 0;
257 }
258 }
259 else
260 {
261 result = 0;
262 }
263
264 return result;
265 }
266
267 static void on_underlying_io_close_complete(void* context)
268 {
269 TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context;
270 if (tls_io_instance->tlsio_state == TLSIO_STATE_CLOSING)
271 {
272 tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN;
273 if (tls_io_instance->on_io_close_complete != NULL)
274 {
275 tls_io_instance->on_io_close_complete(tls_io_instance->on_io_close_complete_context);
276 }
277
278 /* Free security context resources corresponding to creation with open */
279 DeleteSecurityContext(&tls_io_instance->security_context);
280
281 if (tls_io_instance->credential_handle_allocated)
282 {
283 (void)FreeCredentialHandle(&tls_io_instance->credential_handle);
284 tls_io_instance->credential_handle_allocated = false;
285 }
286 }
287 }
288
289 // This callback usage needs to be either verified and commented or integrated into
290 // the state machine.
291 static void unchecked_on_send_complete(void* context, IO_SEND_RESULT send_result)
292 {
293 (void)context;
294 (void)send_result;
295 }
296
297 static void send_client_hello(TLS_IO_INSTANCE* tls_io_instance)
298 {
299 SecBuffer init_security_buffers[2];
300 ULONG context_attributes;
301 SECURITY_STATUS status;
302 SCHANNEL_CRED auth_data;
303 PCCERT_CONTEXT certContext;
304 auth_data.dwVersion = SCHANNEL_CRED_VERSION;
305 if (tls_io_instance->x509_schannel_handle != NULL)
306 {
307 certContext = x509_schannel_get_certificate_context(tls_io_instance->x509_schannel_handle);
308 auth_data.cCreds = 1;
309 auth_data.paCred = &certContext;
310 }
311 else
312 {
313 auth_data.cCreds = 0;
314 auth_data.paCred = NULL;
315 }
316 auth_data.hRootStore = NULL;
317 auth_data.cSupportedAlgs = 0;
318 auth_data.palgSupportedAlgs = NULL;
319 auth_data.grbitEnabledProtocols = 0;
320 auth_data.dwMinimumCipherStrength = 0;
321 auth_data.dwMaximumCipherStrength = 0;
322 auth_data.dwSessionLifespan = 0;
323 #if defined(SCH_USE_STRONG_CRYPTO)
324 auth_data.dwFlags = SCH_USE_STRONG_CRYPTO | SCH_CRED_NO_DEFAULT_CREDS;
325 #else
326 auth_data.dwFlags = SCH_CRED_NO_DEFAULT_CREDS;
327 #endif
328 if (tls_io_instance->ignore_server_name_check)
329 {
330 auth_data.dwFlags |= SCH_CRED_NO_SERVERNAME_CHECK;
331 }
332 auth_data.dwCredFormat = 0;
333
334 if (tls_io_instance->trustedCertificate != NULL)
335 {
336 // SCH_CRED_MANUAL_CRED_VALIDATION flag signals to schannel to NOT use
337 // the Windows certificate store, but instead have application verify
338 // certificate.
339 auth_data.dwFlags |= SCH_CRED_MANUAL_CRED_VALIDATION;
340 }
341
342 status = AcquireCredentialsHandle(NULL, UNISP_NAME, SECPKG_CRED_OUTBOUND, NULL,
343 &auth_data, NULL, NULL, &tls_io_instance->credential_handle, NULL);
344 if (status != SEC_E_OK)
345 {
346 tls_io_instance->tlsio_state = TLSIO_STATE_ERROR;
347 indicate_error(tls_io_instance);
348 }
349 else
350 {
351 SecBufferDesc security_buffers_desc;
352 tls_io_instance->credential_handle_allocated = true;
353
354 init_security_buffers[0].cbBuffer = 0;
355 init_security_buffers[0].BufferType = SECBUFFER_TOKEN;
356 init_security_buffers[0].pvBuffer = NULL;
357 init_security_buffers[1].cbBuffer = 0;
358 init_security_buffers[1].BufferType = SECBUFFER_EMPTY;
359 init_security_buffers[1].pvBuffer = 0;
360
361 security_buffers_desc.cBuffers = 2;
362 security_buffers_desc.pBuffers = init_security_buffers;
363 security_buffers_desc.ulVersion = SECBUFFER_VERSION;
364
365 status = InitializeSecurityContext(&tls_io_instance->credential_handle,
366 NULL, tls_io_instance->host_name, ISC_REQ_EXTENDED_ERROR | ISC_REQ_STREAM | ISC_REQ_ALLOCATE_MEMORY | ISC_REQ_USE_SUPPLIED_CREDS, 0, 0, NULL, 0,
367 &tls_io_instance->security_context, &security_buffers_desc,
368 &context_attributes, NULL);
369
370 if ((status == SEC_I_COMPLETE_NEEDED) || (status == SEC_I_CONTINUE_NEEDED) || (status == SEC_I_COMPLETE_AND_CONTINUE))
371 {
372 if (xio_send(tls_io_instance->socket_io, init_security_buffers[0].pvBuffer, init_security_buffers[0].cbBuffer, unchecked_on_send_complete, NULL) != 0)
373 {
374 tls_io_instance->tlsio_state = TLSIO_STATE_ERROR;
375 indicate_error(tls_io_instance);
376 }
377 else
378 {
379 /* set the needed bytes to 1, to get on the next byte how many we actually need */
380 tls_io_instance->needed_bytes = 1;
381 if (resize_receive_buffer(tls_io_instance, tls_io_instance->needed_bytes + tls_io_instance->received_byte_count) != 0)
382 {
383 tls_io_instance->tlsio_state = TLSIO_STATE_ERROR;
384 indicate_error(tls_io_instance);
385 }
386 else
387 {
388 tls_io_instance->tlsio_state = TLSIO_STATE_HANDSHAKE_CLIENT_HELLO_SENT;
389 }
390 }
391 }
392
393 if (init_security_buffers[0].pvBuffer != NULL)
394 {
395 FreeContextBuffer(init_security_buffers[0].pvBuffer);
396 }
397
398 if (init_security_buffers[1].pvBuffer != NULL)
399 {
400 FreeContextBuffer(init_security_buffers[1].pvBuffer);
401 }
402 }
403 }
404
405 static void on_underlying_io_open_complete(void* context, IO_OPEN_RESULT io_open_result)
406 {
407 TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context;
408
409 if (tls_io_instance->tlsio_state != TLSIO_STATE_OPENING_UNDERLYING_IO)
410 {
411 tls_io_instance->tlsio_state = TLSIO_STATE_ERROR;
412 indicate_error(tls_io_instance);
413 }
414 else
415 {
416 if (io_open_result != IO_OPEN_OK)
417 {
418 tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN;
419 if (tls_io_instance->on_io_open_complete != NULL)
420 {
421 tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, IO_OPEN_ERROR);
422 }
423 }
424 else
425 {
426 send_client_hello(tls_io_instance);
427 }
428 }
429 }
430
431 static int verify_custom_certificate_if_needed(TLS_IO_INSTANCE* tls_io_instance)
432 {
433 int result;
434
435 if (tls_io_instance->trustedCertificate == NULL)
436 {
437 // If there is no trusted certificate set by API caller, then we'll rely on implicit Windows certificate store to verify the certificate.
438 result = 0;
439 }
440 else
441 {
442 PCERT_CONTEXT serverCertificateToVerify = NULL;
443
444 SECURITY_STATUS status = QueryContextAttributes(&tls_io_instance->security_context, SECPKG_ATTR_REMOTE_CERT_CONTEXT, &serverCertificateToVerify);
445 if (status != SEC_E_OK)
446 {
447 LogError("QueryContextAttributes failed: %x", status);
448 result = MU_FAILURE;
449 }
450 else if (x509_verify_certificate_in_chain(tls_io_instance->trustedCertificate, serverCertificateToVerify) != 0)
451 {
452 LogError("Failed to verify trusted certificate in chain");
453 result = MU_FAILURE;
454 }
455 else
456 {
457 result = 0;
458 }
459
460 if (serverCertificateToVerify)
461 {
462 CertFreeCertificateContext(serverCertificateToVerify);
463 }
464 }
465
466 return result;
467 }
468
469 static int set_receive_buffer(TLS_IO_INSTANCE* tls_io_instance, size_t buffer_size)
470 {
471 int result;
472
473 unsigned char* new_buffer = (unsigned char*) realloc(tls_io_instance->received_bytes, buffer_size);
474 if (new_buffer == NULL)
475 {
476 LogError("realloc failed");
477 result = MU_FAILURE;
478 }
479 else
480 {
481 tls_io_instance->received_bytes = new_buffer;
482 tls_io_instance->buffer_size = buffer_size;
483 result = 0;
484 }
485
486 return result;
487 }
488
489 static int send_chunk(CONCRETE_IO_HANDLE tls_io, const void* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context)
490 {
491 int result;
492
493 if ((tls_io == NULL) ||
494 (buffer == NULL) ||
495 (size == 0))
496 {
497 LogError("invalid argument detected: CONCRETE_IO_HANDLE tls_io = %p, const void* buffer = %p, size_t size = %lu", tls_io, buffer, (unsigned long)size);
498 result = MU_FAILURE;
499 }
500 else
501 {
502 TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io;
503 if (tls_io_instance->tlsio_state != TLSIO_STATE_OPEN)
504 {
505 LogError("invalid tls_io_instance->tlsio_state: %" PRI_MU_ENUM "", MU_ENUM_VALUE(TLSIO_STATE, tls_io_instance->tlsio_state));
506 result = MU_FAILURE;
507 }
508 else
509 {
510 SecPkgContext_StreamSizes sizes;
511 SECURITY_STATUS status = QueryContextAttributes(&tls_io_instance->security_context, SECPKG_ATTR_STREAM_SIZES, &sizes);
512 if (status != SEC_E_OK)
513 {
514 LogError("QueryContextAttributes failed: %x", status);
515 result = MU_FAILURE;
516 }
517 else
518 {
519 unsigned char* out_buffer;
520 SecBuffer security_buffers[4];
521 SecBufferDesc security_buffers_desc;
522 size_t needed_buffer = safe_add_size_t(sizes.cbHeader, size);
523 needed_buffer = safe_add_size_t(needed_buffer, sizes.cbTrailer);
524 if (needed_buffer == SIZE_MAX ||
525 (out_buffer = (unsigned char*)malloc(needed_buffer)) == NULL)
526 {
527 LogError("malloc failed, size:%zu", needed_buffer);
528 result = MU_FAILURE;
529 }
530 else
531 {
532 (void)memcpy(out_buffer + sizes.cbHeader, buffer, size);
533
534 security_buffers[0].BufferType = SECBUFFER_STREAM_HEADER;
535 security_buffers[0].cbBuffer = sizes.cbHeader;
536 security_buffers[0].pvBuffer = out_buffer;
537 security_buffers[1].BufferType = SECBUFFER_DATA;
538 security_buffers[1].cbBuffer = (unsigned long)size;
539 security_buffers[1].pvBuffer = out_buffer + sizes.cbHeader;
540 security_buffers[2].BufferType = SECBUFFER_STREAM_TRAILER;
541 security_buffers[2].cbBuffer = sizes.cbTrailer;
542 security_buffers[2].pvBuffer = out_buffer + sizes.cbHeader + size;
543 security_buffers[3].cbBuffer = 0;
544 security_buffers[3].BufferType = SECBUFFER_EMPTY;
545 security_buffers[3].pvBuffer = 0;
546
547 security_buffers_desc.cBuffers = sizeof(security_buffers) / sizeof(security_buffers[0]);
548 security_buffers_desc.pBuffers = security_buffers;
549 security_buffers_desc.ulVersion = SECBUFFER_VERSION;
550
551 status = EncryptMessage(&tls_io_instance->security_context, 0, &security_buffers_desc, 0);
552 if (FAILED(status))
553 {
554 LogError("EncryptMessage failed: %x", status);
555 result = MU_FAILURE;
556 }
557 else
558 {
559 if (xio_send(tls_io_instance->socket_io, out_buffer, (size_t)security_buffers[0].cbBuffer + (size_t)security_buffers[1].cbBuffer + (size_t)security_buffers[2].cbBuffer, on_send_complete, callback_context) != 0)
560 {
561 LogError("xio_send failed");
562 result = MU_FAILURE;
563 }
564 else
565 {
566 result = 0;
567 }
568 }
569
570 free(out_buffer);
571 }
572 }
573 }
574 }
575
576 return result;
577 }
578
579 static int internal_send(TLS_IO_INSTANCE* tls_io_instance, const void* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context)
580 {
581 int result;
582
583 while (size > 0)
584 {
585 size_t to_send = 16 * 1024;
586 if (to_send > size)
587 {
588 to_send = size;
589 }
590
591 if (send_chunk(tls_io_instance, buffer, to_send, (to_send == size) ? on_send_complete : NULL, callback_context) != 0)
592 {
593 break;
594 }
595
596 size -= to_send;
597 buffer = ((const unsigned char*)buffer) + to_send;
598 }
599
600 if (size > 0)
601 {
602 LogError("send_chunk failed");
603 result = MU_FAILURE;
604 }
605 else
606 {
607 result = 0;
608 }
609
610 return result;
611 }
612
613 static void on_underlying_io_bytes_received(void* context, const unsigned char* buffer, size_t size)
614 {
615 TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context;
616 size_t consumed_bytes;
617
618 if (resize_receive_buffer(tls_io_instance, tls_io_instance->received_byte_count + size) == 0)
619 {
620 (void)memcpy(tls_io_instance->received_bytes + tls_io_instance->received_byte_count, buffer, size);
621 tls_io_instance->received_byte_count += size;
622
623 if (size > tls_io_instance->needed_bytes)
624 {
625 tls_io_instance->needed_bytes = 0;
626 }
627 else
628 {
629 tls_io_instance->needed_bytes -= size;
630 }
631
632 /* Drain what we received */
633 while (tls_io_instance->needed_bytes == 0)
634 {
635 if ((tls_io_instance->tlsio_state == TLSIO_STATE_HANDSHAKE_CLIENT_HELLO_SENT) ||
636 (tls_io_instance->tlsio_state == TLSIO_STATE_RENEGOTIATE))
637 {
638 SecBuffer input_buffers[2];
639 SecBuffer output_buffers[2];
640 SecBufferDesc input_buffers_desc;
641 SecBufferDesc output_buffers_desc;
642 SECURITY_STATUS status;
643 unsigned long flags;
644 ULONG context_attributes;
645
646 /* we need to try and perform the second (next) step of the init */
647 input_buffers[0].cbBuffer = (unsigned long)tls_io_instance->received_byte_count;
648 input_buffers[0].BufferType = SECBUFFER_TOKEN;
649 input_buffers[0].pvBuffer = (void*)tls_io_instance->received_bytes;
650 input_buffers[1].cbBuffer = 0;
651 input_buffers[1].BufferType = SECBUFFER_EMPTY;
652 input_buffers[1].pvBuffer = 0;
653
654 input_buffers_desc.cBuffers = 2;
655 input_buffers_desc.pBuffers = input_buffers;
656 input_buffers_desc.ulVersion = SECBUFFER_VERSION;
657
658 output_buffers[0].cbBuffer = 0;
659 output_buffers[0].BufferType = SECBUFFER_TOKEN;
660 output_buffers[0].pvBuffer = NULL;
661 output_buffers[1].cbBuffer = 0;
662 output_buffers[1].BufferType = SECBUFFER_EMPTY;
663 output_buffers[1].pvBuffer = 0;
664
665 output_buffers_desc.cBuffers = 2;
666 output_buffers_desc.pBuffers = output_buffers;
667 output_buffers_desc.ulVersion = SECBUFFER_VERSION;
668
669 flags = ISC_REQ_EXTENDED_ERROR | ISC_REQ_STREAM | ISC_REQ_ALLOCATE_MEMORY | ISC_REQ_USE_SUPPLIED_CREDS;
670 status = InitializeSecurityContext(&tls_io_instance->credential_handle,
671 &tls_io_instance->security_context, tls_io_instance->host_name, flags, 0, 0, &input_buffers_desc, 0,
672 &tls_io_instance->security_context, &output_buffers_desc,
673 &context_attributes, NULL);
674
675 switch (status)
676 {
677 case SEC_E_INCOMPLETE_MESSAGE:
678 if (input_buffers[1].BufferType != SECBUFFER_MISSING)
679 {
680 //If SECBUFFER_MISSING not sent, try to read byte by byte.
681 tls_io_instance->needed_bytes = 1;
682 }
683 else
684 {
685 tls_io_instance->needed_bytes = input_buffers[1].cbBuffer;
686 }
687
688 if (resize_receive_buffer(tls_io_instance, tls_io_instance->received_byte_count + tls_io_instance->needed_bytes) != 0)
689 {
690 tls_io_instance->tlsio_state = TLSIO_STATE_ERROR;
691 if (tls_io_instance->on_io_open_complete != NULL)
692 {
693 tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, IO_OPEN_ERROR);
694 }
695 }
696
697 break;
698 case SEC_E_OK:
699 consumed_bytes = tls_io_instance->received_byte_count;
700 /* Any extra bytes left over or did we fully consume the receive buffer? */
701 if (input_buffers[1].BufferType == SECBUFFER_EXTRA)
702 {
703 consumed_bytes -= input_buffers[1].cbBuffer;
704 (void)memmove(tls_io_instance->received_bytes, tls_io_instance->received_bytes + consumed_bytes, tls_io_instance->received_byte_count - consumed_bytes);
705 }
706 tls_io_instance->received_byte_count -= consumed_bytes;
707
708 /* if nothing more to consume, set the needed bytes to 1, to get on the next byte how many we actually need */
709 tls_io_instance->needed_bytes = tls_io_instance->received_byte_count == 0 ? 1 : 0;
710
711 if (verify_custom_certificate_if_needed(tls_io_instance) != 0)
712 {
713 LogError("Unable to verify server certificate against custom server trusted certificate");
714 if (tls_io_instance->on_io_open_complete != NULL)
715 {
716 tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, IO_OPEN_ERROR);
717 }
718 }
719 else if (set_receive_buffer(tls_io_instance, tls_io_instance->needed_bytes + tls_io_instance->received_byte_count) != 0)
720 {
721 tls_io_instance->tlsio_state = TLSIO_STATE_ERROR;
722 if (tls_io_instance->on_io_open_complete != NULL)
723 {
724 tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, IO_OPEN_ERROR);
725 }
726 }
727 else
728 {
729 if (tls_io_instance->tlsio_state == TLSIO_STATE_HANDSHAKE_CLIENT_HELLO_SENT)
730 {
731 tls_io_instance->tlsio_state = TLSIO_STATE_OPEN;
732
733 if (tls_io_instance->on_io_open_complete != NULL)
734 {
735 tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, IO_OPEN_OK);
736 }
737 }
738 else
739 {
740 LIST_ITEM_HANDLE first_pending_io;
741 tls_io_instance->tlsio_state = TLSIO_STATE_OPEN;
742
743 first_pending_io = singlylinkedlist_get_head_item(tls_io_instance->pending_io_list);
744 while (first_pending_io != NULL)
745 {
746 PENDING_SEND* pending_send = (PENDING_SEND*)singlylinkedlist_item_get_value(first_pending_io);
747 if (pending_send == NULL)
748 {
749 LogError("Failure: retrieving pending IO from list");
750 indicate_error(tls_io_instance);
751 break;
752 }
753 else
754 {
755 if (internal_send(tls_io_instance, pending_send->bytes, pending_send->length, pending_send->on_send_complete, pending_send->on_send_complete_context) != 0)
756 {
757 LogError("send failed");
758 indicate_error(tls_io_instance);
759 }
760 else
761 {
762 if (singlylinkedlist_remove(tls_io_instance->pending_io_list, first_pending_io) != 0)
763 {
764 LogError("Failure: removing pending IO from list");
765 indicate_error(tls_io_instance);
766 }
767 }
768
769 first_pending_io = singlylinkedlist_get_head_item(tls_io_instance->pending_io_list);
770 }
771 }
772 }
773 }
774 break;
775 case SEC_I_COMPLETE_NEEDED:
776 case SEC_I_CONTINUE_NEEDED:
777 case SEC_I_COMPLETE_AND_CONTINUE:
778 if ((output_buffers[0].cbBuffer > 0) && xio_send(tls_io_instance->socket_io, output_buffers[0].pvBuffer, output_buffers[0].cbBuffer, unchecked_on_send_complete, NULL) != 0)
779 {
780 tls_io_instance->tlsio_state = TLSIO_STATE_ERROR;
781 if (tls_io_instance->on_io_open_complete != NULL)
782 {
783 tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, IO_OPEN_ERROR);
784 }
785 }
786 else
787 {
788 consumed_bytes = tls_io_instance->received_byte_count;
789 /* Any extra bytes left over or did we fully consume the receive buffer? */
790 if (input_buffers[1].BufferType == SECBUFFER_EXTRA)
791 {
792 consumed_bytes -= input_buffers[1].cbBuffer;
793 (void)memmove(tls_io_instance->received_bytes, tls_io_instance->received_bytes + consumed_bytes, tls_io_instance->received_byte_count - consumed_bytes);
794 }
795 tls_io_instance->received_byte_count -= consumed_bytes;
796
797 /* if nothing more to consume, set the needed bytes to 1, to get on the next byte how many we actually need */
798 tls_io_instance->needed_bytes = tls_io_instance->received_byte_count == 0 ? 1 : 0;
799
800 if (set_receive_buffer(tls_io_instance, tls_io_instance->needed_bytes + tls_io_instance->received_byte_count) != 0)
801 {
802 tls_io_instance->tlsio_state = TLSIO_STATE_ERROR;
803 if (tls_io_instance->on_io_open_complete != NULL)
804 {
805 tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, IO_OPEN_ERROR);
806 }
807 }
808 else
809 {
810 if (tls_io_instance->tlsio_state != TLSIO_STATE_RENEGOTIATE)
811 {
812 tls_io_instance->tlsio_state = TLSIO_STATE_HANDSHAKE_CLIENT_HELLO_SENT;
813 }
814 }
815 }
816 break;
817 case SEC_E_UNTRUSTED_ROOT:
818 tls_io_instance->tlsio_state = TLSIO_STATE_ERROR;
819 if (tls_io_instance->on_io_open_complete != NULL)
820 {
821 tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, IO_OPEN_ERROR);
822 }
823 break;
824 default:
825 {
826 LPVOID srcText = NULL;
827 if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
828 status, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&srcText, 0, NULL) > 0)
829 {
830 LogError("[%#x] %s", status, (LPTSTR)srcText);
831 LocalFree(srcText);
832 }
833 else
834 {
835 LogError("[%#x]", status);
836 }
837
838 tls_io_instance->tlsio_state = TLSIO_STATE_ERROR;
839 indicate_error(tls_io_instance);
840 }
841 break;
842 }
843
844 if (output_buffers[0].pvBuffer != NULL)
845 {
846 FreeContextBuffer(output_buffers[0].pvBuffer);
847 output_buffers[0].pvBuffer = NULL;
848 }
849
850 if (output_buffers[1].pvBuffer != NULL)
851 {
852 FreeContextBuffer(output_buffers[1].pvBuffer);
853 output_buffers[1].pvBuffer = NULL;
854 }
855 }
856 else if (tls_io_instance->tlsio_state == TLSIO_STATE_OPEN)
857 {
858 SecBuffer security_buffers[4];
859 SecBufferDesc security_buffers_desc;
860 SECURITY_STATUS status;
861
862 security_buffers[0].BufferType = SECBUFFER_DATA;
863 security_buffers[0].pvBuffer = tls_io_instance->received_bytes;
864 security_buffers[0].cbBuffer = (unsigned long)tls_io_instance->received_byte_count;
865 security_buffers[1].BufferType = SECBUFFER_EMPTY;
866 security_buffers[2].BufferType = SECBUFFER_EMPTY;
867 security_buffers[3].BufferType = SECBUFFER_EMPTY;
868
869 security_buffers_desc.cBuffers = sizeof(security_buffers) / sizeof(security_buffers[0]);
870 security_buffers_desc.pBuffers = security_buffers;
871 security_buffers_desc.ulVersion = SECBUFFER_VERSION;
872
873 status = DecryptMessage(&tls_io_instance->security_context, &security_buffers_desc, 0, NULL);
874 switch (status)
875 {
876 case SEC_E_INCOMPLETE_MESSAGE:
877 if (security_buffers[1].BufferType != SECBUFFER_MISSING)
878 {
879 //If SECBUFFER_MISSING not sent, try to read byte by byte.
880 tls_io_instance->needed_bytes = 1;
881 }
882 else
883 {
884 tls_io_instance->needed_bytes = security_buffers[1].cbBuffer;
885 }
886
887 if (resize_receive_buffer(tls_io_instance, tls_io_instance->received_byte_count + tls_io_instance->needed_bytes) != 0)
888 {
889 tls_io_instance->tlsio_state = TLSIO_STATE_ERROR;
890 indicate_error(tls_io_instance);
891 }
892 break;
893 case SEC_E_OK:
894 if (security_buffers[1].BufferType != SECBUFFER_DATA)
895 {
896 tls_io_instance->tlsio_state = TLSIO_STATE_ERROR;
897 indicate_error(tls_io_instance);
898 }
899 else
900 {
901 size_t i;
902
903 /* notify of the received data */
904 if (tls_io_instance->on_bytes_received != NULL)
905 {
906 tls_io_instance->on_bytes_received(tls_io_instance->on_bytes_received_context, (const unsigned char *) security_buffers[1].pvBuffer, security_buffers[1].cbBuffer);
907 }
908
909 consumed_bytes = tls_io_instance->received_byte_count;
910
911 for (i = 0; i < sizeof(security_buffers) / sizeof(security_buffers[0]); i++)
912 {
913 /* Any extra bytes left over or did we fully consume the receive buffer? */
914 if (security_buffers[i].BufferType == SECBUFFER_EXTRA)
915 {
916 consumed_bytes -= security_buffers[i].cbBuffer;
917 (void)memmove(tls_io_instance->received_bytes, tls_io_instance->received_bytes + consumed_bytes, tls_io_instance->received_byte_count - consumed_bytes);
918 break;
919 }
920 }
921 tls_io_instance->received_byte_count -= consumed_bytes;
922
923 /* if nothing more to consume, set the needed bytes to 1, to get on the next byte how many we actually need */
924 tls_io_instance->needed_bytes = tls_io_instance->received_byte_count == 0 ? 1 : 0;
925
926 if (set_receive_buffer(tls_io_instance, tls_io_instance->needed_bytes + tls_io_instance->received_byte_count) != 0)
927 {
928 tls_io_instance->tlsio_state = TLSIO_STATE_ERROR;
929 indicate_error(tls_io_instance);
930 }
931 }
932 break;
933 case SEC_I_RENEGOTIATE:
934 {
935 SecBuffer input_buffers[2];
936 SecBuffer output_buffers[2];
937 SecBufferDesc input_buffers_desc;
938 SecBufferDesc output_buffers_desc;
939 unsigned long flags;
940 ULONG context_attributes;
941
942 /* we need to try and perform the second (next) step of the init */
943 input_buffers[0].cbBuffer = (unsigned long)tls_io_instance->received_byte_count;
944 input_buffers[0].BufferType = SECBUFFER_TOKEN;
945 input_buffers[0].pvBuffer = (void*)tls_io_instance->received_bytes;
946 input_buffers[1].cbBuffer = 0;
947 input_buffers[1].BufferType = SECBUFFER_EMPTY;
948 input_buffers[1].pvBuffer = 0;
949
950 input_buffers_desc.cBuffers = 2;
951 input_buffers_desc.pBuffers = input_buffers;
952 input_buffers_desc.ulVersion = SECBUFFER_VERSION;
953
954 output_buffers[0].cbBuffer = 0;
955 output_buffers[0].BufferType = SECBUFFER_TOKEN;
956 output_buffers[0].pvBuffer = NULL;
957 output_buffers[1].cbBuffer = 0;
958 output_buffers[1].BufferType = SECBUFFER_EMPTY;
959 output_buffers[1].pvBuffer = 0;
960
961 output_buffers_desc.cBuffers = 2;
962 output_buffers_desc.pBuffers = output_buffers;
963 output_buffers_desc.ulVersion = SECBUFFER_VERSION;
964
965 flags = ISC_REQ_EXTENDED_ERROR | ISC_REQ_STREAM | ISC_REQ_ALLOCATE_MEMORY | ISC_REQ_USE_SUPPLIED_CREDS;
966 status = InitializeSecurityContext(&tls_io_instance->credential_handle,
967 &tls_io_instance->security_context, tls_io_instance->host_name, flags, 0, 0, &input_buffers_desc, 0,
968 &tls_io_instance->security_context, &output_buffers_desc,
969 &context_attributes, NULL);
970
971 if ((status == SEC_I_COMPLETE_NEEDED) || (status == SEC_I_CONTINUE_NEEDED) || (status == SEC_I_COMPLETE_AND_CONTINUE))
972 {
973 /* This needs to account for EXTRA */
974 tls_io_instance->received_byte_count = 0;
975
976 if (xio_send(tls_io_instance->socket_io, output_buffers[0].pvBuffer, output_buffers[0].cbBuffer, unchecked_on_send_complete, NULL) != 0)
977 {
978 tls_io_instance->tlsio_state = TLSIO_STATE_ERROR;
979 indicate_error(tls_io_instance);
980 }
981 else
982 {
983 tls_io_instance->needed_bytes = 1;
984 if (resize_receive_buffer(tls_io_instance, tls_io_instance->needed_bytes + tls_io_instance->received_byte_count) != 0)
985 {
986 tls_io_instance->tlsio_state = TLSIO_STATE_ERROR;
987 indicate_error(tls_io_instance);
988 }
989 else
990 {
991 tls_io_instance->tlsio_state = TLSIO_STATE_RENEGOTIATE;
992 }
993 }
994 }
995
996 if (output_buffers[0].pvBuffer != NULL)
997 {
998 FreeContextBuffer(output_buffers[0].pvBuffer);
999 output_buffers[0].pvBuffer = NULL;
1000 }
1001
1002 if (output_buffers[1].pvBuffer != NULL)
1003 {
1004 FreeContextBuffer(output_buffers[1].pvBuffer);
1005 output_buffers[1].pvBuffer = NULL;
1006 }
1007 break;
1008 }
1009
1010 default:
1011 {
1012 LPVOID srcText = NULL;
1013 if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
1014 status, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&srcText, 0, NULL) > 0)
1015 {
1016 LogError("[%#x] %s", status, (LPTSTR)srcText);
1017 LocalFree(srcText);
1018 }
1019 else
1020 {
1021 LogError("[%#x]", status);
1022 }
1023
1024 tls_io_instance->tlsio_state = TLSIO_STATE_ERROR;
1025 indicate_error(tls_io_instance);
1026 }
1027 break;
1028 }
1029 }
1030 else
1031 {
1032 /* Received data in error or other state */
1033 break;
1034 }
1035 }
1036
1037 }
1038 }
1039
1040 static void on_underlying_io_error(void* context)
1041 {
1042 TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)context;
1043
1044 switch (tls_io_instance->tlsio_state)
1045 {
1046 default:
1047 case TLSIO_STATE_NOT_OPEN:
1048 case TLSIO_STATE_ERROR:
1049 break;
1050
1051 case TLSIO_STATE_OPENING_UNDERLYING_IO:
1052 case TLSIO_STATE_HANDSHAKE_CLIENT_HELLO_SENT:
1053 case TLSIO_STATE_HANDSHAKE_SERVER_HELLO_RECEIVED:
1054 tls_io_instance->tlsio_state = TLSIO_STATE_ERROR;
1055 if (tls_io_instance->on_io_open_complete != NULL)
1056 {
1057 tls_io_instance->on_io_open_complete(tls_io_instance->on_io_open_complete_context, IO_OPEN_ERROR);
1058 }
1059 break;
1060
1061 case TLSIO_STATE_CLOSING:
1062 tls_io_instance->tlsio_state = TLSIO_STATE_ERROR;
1063 if (tls_io_instance->on_io_close_complete != NULL)
1064 {
1065 tls_io_instance->on_io_close_complete(tls_io_instance->on_io_close_complete_context);
1066 }
1067 break;
1068
1069 case TLSIO_STATE_OPEN:
1070 tls_io_instance->tlsio_state = TLSIO_STATE_ERROR;
1071 indicate_error(tls_io_instance);
1072 break;
1073 }
1074 }
1075
1076 CONCRETE_IO_HANDLE tlsio_schannel_create(void* io_create_parameters)
1077 {
1078 TLSIO_CONFIG* tls_io_config = (TLSIO_CONFIG *) io_create_parameters;
1079 TLS_IO_INSTANCE* result;
1080
1081 if (tls_io_config == NULL)
1082 {
1083 LogError("invalid argument detected: void* io_create_parameters = %p", tls_io_config);
1084 result = NULL;
1085 }
1086 else
1087 {
1088 result = (TLS_IO_INSTANCE*)malloc(sizeof(TLS_IO_INSTANCE));
1089 if (result == NULL)
1090 {
1091 LogError("malloc failed");
1092 }
1093 else
1094 {
1095 (void)memset(result, 0, sizeof(TLS_IO_INSTANCE));
1096
1097 size_t malloc_size = safe_add_size_t(strlen(tls_io_config->hostname), 1);
1098 malloc_size = safe_multiply_size_t(malloc_size, sizeof(SEC_TCHAR));
1099 if (malloc_size == SIZE_MAX ||
1100 (result->host_name = (SEC_TCHAR*)malloc(malloc_size)) == NULL)
1101 {
1102 LogError("malloc failed, size:%zu", malloc_size);
1103 free(result);
1104 result = NULL;
1105 }
1106 else
1107 {
1108 SOCKETIO_CONFIG socketio_config;
1109 const IO_INTERFACE_DESCRIPTION* underlying_io_interface;
1110 void* io_interface_parameters;
1111
1112 (void)strcpy(result->host_name, tls_io_config->hostname);
1113
1114 if (tls_io_config->underlying_io_interface != NULL)
1115 {
1116 underlying_io_interface = tls_io_config->underlying_io_interface;
1117 io_interface_parameters = tls_io_config->underlying_io_parameters;
1118 }
1119 else
1120 {
1121 socketio_config.hostname = tls_io_config->hostname;
1122 socketio_config.port = tls_io_config->port;
1123 socketio_config.accepted_socket = NULL;
1124
1125 underlying_io_interface = socketio_get_interface_description();
1126 io_interface_parameters = &socketio_config;
1127 }
1128
1129 if (underlying_io_interface == NULL)
1130 {
1131 LogError("socketio_get_interface_description failed");
1132 free(result->host_name);
1133 free(result);
1134 result = NULL;
1135 }
1136 else
1137 {
1138 result->socket_io = xio_create(underlying_io_interface, io_interface_parameters);
1139 if (result->socket_io == NULL)
1140 {
1141 LogError("xio_create failed");
1142 free(result->host_name);
1143 free(result);
1144 result = NULL;
1145 }
1146 else
1147 {
1148 result->pending_io_list = singlylinkedlist_create();
1149 if (result->pending_io_list == NULL)
1150 {
1151 LogError("Failed creating pending IO list.");
1152 xio_destroy(result->socket_io);
1153 free(result->host_name);
1154 free(result);
1155 result = NULL;
1156 }
1157 else
1158 {
1159 result->received_bytes = NULL;
1160 result->received_byte_count = 0;
1161 result->buffer_size = 0;
1162 result->tlsio_state = TLSIO_STATE_NOT_OPEN;
1163 result->x509certificate = NULL;
1164 result->x509privatekey = NULL;
1165 result->x509_schannel_handle = NULL;
1166 }
1167 }
1168 }
1169 }
1170 }
1171 }
1172
1173 return result;
1174 }
1175
1176 void tlsio_schannel_destroy(CONCRETE_IO_HANDLE tls_io)
1177 {
1178 if (tls_io != NULL)
1179 {
1180 TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io;
1181 LIST_ITEM_HANDLE first_pending_io;
1182
1183 if (tls_io_instance->credential_handle_allocated)
1184 {
1185 (void)FreeCredentialHandle(&tls_io_instance->credential_handle);
1186 tls_io_instance->credential_handle_allocated = false;
1187 }
1188
1189 if (tls_io_instance->received_bytes != NULL)
1190 {
1191 free(tls_io_instance->received_bytes);
1192 tls_io_instance->received_bytes = NULL;
1193 }
1194
1195 if (tls_io_instance->trustedCertificate != NULL)
1196 {
1197 free(tls_io_instance->trustedCertificate);
1198 tls_io_instance->trustedCertificate = NULL;
1199 }
1200
1201 if (tls_io_instance->x509_schannel_handle != NULL)
1202 {
1203 x509_schannel_destroy(tls_io_instance->x509_schannel_handle);
1204 tls_io_instance->x509_schannel_handle = NULL;
1205 }
1206
1207 if (tls_io_instance->x509certificate != NULL)
1208 {
1209 free(tls_io_instance->x509certificate);
1210 tls_io_instance->x509certificate = NULL;
1211 }
1212
1213 if (tls_io_instance->x509privatekey != NULL)
1214 {
1215 free(tls_io_instance->x509privatekey);
1216 tls_io_instance->x509privatekey = NULL;
1217 }
1218
1219 xio_destroy(tls_io_instance->socket_io);
1220 tls_io_instance->socket_io = NULL;
1221
1222 free(tls_io_instance->host_name);
1223 tls_io_instance->host_name = NULL;
1224
1225 first_pending_io = singlylinkedlist_get_head_item(tls_io_instance->pending_io_list);
1226 while (first_pending_io != NULL)
1227 {
1228 PENDING_SEND* pending_send = (PENDING_SEND*)singlylinkedlist_item_get_value(first_pending_io);
1229 if (pending_send == NULL)
1230 {
1231 LogError("Failure: retrieving socket from list");
1232 indicate_error(tls_io_instance);
1233 break;
1234 }
1235 else
1236 {
1237 if (pending_send->on_send_complete != NULL)
1238 {
1239 pending_send->on_send_complete(pending_send->on_send_complete_context, IO_SEND_CANCELLED);
1240 }
1241
1242 if (singlylinkedlist_remove(tls_io_instance->pending_io_list, first_pending_io) != 0)
1243 {
1244 LogError("Failure: removing pending IO from list");
1245 indicate_error(tls_io_instance);
1246 break;
1247 }
1248
1249 first_pending_io = singlylinkedlist_get_head_item(tls_io_instance->pending_io_list);
1250 }
1251 }
1252
1253 singlylinkedlist_destroy(tls_io_instance->pending_io_list);
1254 free(tls_io);
1255 }
1256 }
1257
1258 int tlsio_schannel_open(CONCRETE_IO_HANDLE tls_io, ON_IO_OPEN_COMPLETE on_io_open_complete, void* on_io_open_complete_context, ON_BYTES_RECEIVED on_bytes_received, void* on_bytes_received_context, ON_IO_ERROR on_io_error, void* on_io_error_context)
1259 {
1260 int result;
1261
1262 if (tls_io == NULL)
1263 {
1264 LogError("invalid argument detected: CONCRETE_IO_HANDLE tls_io = %p", tls_io);
1265 result = MU_FAILURE;
1266 }
1267 else
1268 {
1269 TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io;
1270
1271 if (tls_io_instance->tlsio_state != TLSIO_STATE_NOT_OPEN)
1272 {
1273 LogError("invalid tls_io_instance->tlsio_state = %" PRI_MU_ENUM "", MU_ENUM_VALUE(TLSIO_STATE, tls_io_instance->tlsio_state));
1274 result = MU_FAILURE;
1275 }
1276 else
1277 {
1278 tls_io_instance->on_io_open_complete = on_io_open_complete;
1279 tls_io_instance->on_io_open_complete_context = on_io_open_complete_context;
1280
1281 tls_io_instance->on_bytes_received = on_bytes_received;
1282 tls_io_instance->on_bytes_received_context = on_bytes_received_context;
1283
1284 tls_io_instance->on_io_error = on_io_error;
1285 tls_io_instance->on_io_error_context = on_io_error_context;
1286
1287 tls_io_instance->tlsio_state = TLSIO_STATE_OPENING_UNDERLYING_IO;
1288
1289 if (xio_open(tls_io_instance->socket_io, on_underlying_io_open_complete, tls_io_instance, on_underlying_io_bytes_received, tls_io_instance, on_underlying_io_error, tls_io_instance) != 0)
1290 {
1291 LogError("xio_open failed");
1292 tls_io_instance->tlsio_state = TLSIO_STATE_NOT_OPEN;
1293 result = MU_FAILURE;
1294 }
1295 else
1296 {
1297 result = 0;
1298 }
1299 }
1300 }
1301
1302 return result;
1303 }
1304
1305 int tlsio_schannel_close(CONCRETE_IO_HANDLE tls_io, ON_IO_CLOSE_COMPLETE on_io_close_complete, void* callback_context)
1306 {
1307 int result = 0;
1308
1309 if (tls_io == NULL)
1310 {
1311 LogError("invalid argument detected: tls_io = %p", tls_io);
1312 result = MU_FAILURE;
1313 }
1314 else
1315 {
1316 TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io;
1317
1318 if ((tls_io_instance->tlsio_state == TLSIO_STATE_NOT_OPEN) ||
1319 (tls_io_instance->tlsio_state == TLSIO_STATE_CLOSING))
1320 {
1321 LogError("invalid tls_io_instance->tlsio_state = %" PRI_MU_ENUM "", MU_ENUM_VALUE(TLSIO_STATE, tls_io_instance->tlsio_state));
1322 result = MU_FAILURE;
1323 }
1324 else
1325 {
1326 tls_io_instance->tlsio_state = TLSIO_STATE_CLOSING;
1327 tls_io_instance->on_io_close_complete = on_io_close_complete;
1328 tls_io_instance->on_io_close_complete_context = callback_context;
1329 if (xio_close(tls_io_instance->socket_io, on_underlying_io_close_complete, tls_io_instance) != 0)
1330 {
1331 LogError("xio_close failed");
1332 result = MU_FAILURE;
1333 }
1334 else
1335 {
1336 result = 0;
1337 }
1338 }
1339 }
1340
1341 return result;
1342 }
1343
1344 int tlsio_schannel_send(CONCRETE_IO_HANDLE tls_io, const void* buffer, size_t size, ON_SEND_COMPLETE on_send_complete, void* callback_context)
1345 {
1346 int result;
1347 TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io;
1348
1349 if (tls_io_instance->tlsio_state == TLSIO_STATE_RENEGOTIATE)
1350 {
1351 /* add to pending list */
1352 PENDING_SEND* new_pending_send = (PENDING_SEND*)calloc(1, sizeof(PENDING_SEND));
1353 if (new_pending_send == NULL)
1354 {
1355 LogError("Cannot allocate memory for pending IO");
1356 result = MU_FAILURE;
1357 }
1358 else
1359 {
1360 new_pending_send->bytes = (unsigned char*)malloc(size);
1361 if (new_pending_send->bytes == NULL)
1362 {
1363 LogError("Cannot allocate memory for pending IO payload");
1364 result = MU_FAILURE;
1365 }
1366 else
1367 {
1368 (void)memcpy(new_pending_send->bytes, buffer, size);
1369 new_pending_send->length = size;
1370 new_pending_send->on_send_complete = on_send_complete;
1371 new_pending_send->on_send_complete_context = callback_context;
1372
1373 if (singlylinkedlist_add(tls_io_instance->pending_io_list, new_pending_send) == NULL)
1374 {
1375 LogError("Cannot add pending IO to list");
1376 result = MU_FAILURE;
1377 }
1378 else
1379 {
1380 result = 0;
1381 }
1382 }
1383 }
1384 }
1385 else
1386 {
1387 if (internal_send((TLS_IO_INSTANCE*)tls_io, buffer, size, on_send_complete, callback_context) != 0)
1388 {
1389 LogError("send failed");
1390 result = MU_FAILURE;
1391 }
1392 else
1393 {
1394 result = 0;
1395 }
1396 }
1397
1398 return result;
1399 }
1400
1401 void tlsio_schannel_dowork(CONCRETE_IO_HANDLE tls_io)
1402 {
1403 if (tls_io != NULL)
1404 {
1405 TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io;
1406 xio_dowork(tls_io_instance->socket_io);
1407 }
1408 }
1409
1410 int tlsio_schannel_setoption(CONCRETE_IO_HANDLE tls_io, const char* optionName, const void* value)
1411 {
1412 int result;
1413
1414 if (tls_io == NULL || optionName == NULL)
1415 {
1416 LogError("invalid argument detected: CONCRETE_IO_HANDLE tls_io = %p, const char* optionName = %p", tls_io, optionName);
1417 result = MU_FAILURE;
1418 }
1419 else
1420 {
1421 TLS_IO_INSTANCE* tls_io_instance = (TLS_IO_INSTANCE*)tls_io;
1422 if (strcmp(SU_OPTION_X509_CERT, optionName) == 0 || strcmp(OPTION_X509_ECC_CERT, optionName) == 0)
1423 {
1424 if (tls_io_instance->x509certificate != NULL)
1425 {
1426 LogError("x509certificate has already been specified");
1427 result = MU_FAILURE;
1428 }
1429 else
1430 {
1431 tls_io_instance->x509certificate = (char *)tlsio_schannel_CloneOption(optionName, value);
1432 if (tls_io_instance->x509certificate == NULL)
1433 {
1434 LogError("tlsio_schannel_CloneOption failed");
1435 result = MU_FAILURE;
1436 }
1437 else
1438 {
1439 if (tls_io_instance->x509privatekey != NULL)
1440 {
1441 tls_io_instance->x509_schannel_handle = x509_schannel_create(tls_io_instance->x509certificate, tls_io_instance->x509privatekey);
1442 if (tls_io_instance->x509_schannel_handle == NULL)
1443 {
1444 LogError("x509_schannel_create failed");
1445 result = MU_FAILURE;
1446 }
1447 else
1448 {
1449 /*all is fine, the x509 shall be used later*/
1450 result = 0;
1451 }
1452 }
1453 else
1454 {
1455 result = 0; /*all is fine, maybe x509 privatekey will come and then x509 is set*/
1456 }
1457 }
1458 }
1459 }
1460 else if (strcmp(SU_OPTION_X509_PRIVATE_KEY, optionName) == 0 || strcmp(OPTION_X509_ECC_KEY, optionName) == 0)
1461 {
1462 if (tls_io_instance->x509privatekey != NULL)
1463 {
1464 LogError("x509privatekey has already been specified");
1465 result = MU_FAILURE;
1466 }
1467 else
1468 {
1469 tls_io_instance->x509privatekey = (char *)tlsio_schannel_CloneOption(optionName, value);
1470 if (tls_io_instance->x509privatekey == NULL)
1471 {
1472 LogError("tlsio_schannel_CloneOption failed");
1473 result = MU_FAILURE;
1474 }
1475 else
1476 {
1477 if (tls_io_instance->x509certificate != NULL)
1478 {
1479 tls_io_instance->x509_schannel_handle = x509_schannel_create(tls_io_instance->x509certificate, tls_io_instance->x509privatekey);
1480 if (tls_io_instance->x509_schannel_handle == NULL)
1481 {
1482 LogError("x509_schannel_create failed");
1483 result = MU_FAILURE;
1484 }
1485 else
1486 {
1487 /*all is fine, the x509 shall be used later*/
1488 result = 0;
1489 }
1490 }
1491 else
1492 {
1493 result = 0; /*all is fine, maybe x509 cert will come and then x509 is set*/
1494 }
1495 }
1496 }
1497 }
1498 else if (strcmp(OPTION_TRUSTED_CERT, optionName) == 0)
1499 {
1500 if (value == NULL)
1501 {
1502 LogError("Invalid paramater: OPTION_TRUSTED_CERT value=NULL");
1503 result = MU_FAILURE;
1504 }
1505 else
1506 {
1507 if (tls_io_instance->trustedCertificate != NULL)
1508 {
1509 free(tls_io_instance->trustedCertificate);
1510 tls_io_instance->trustedCertificate = NULL;
1511 }
1512
1513 if (mallocAndStrcpy_s((char**)&tls_io_instance->trustedCertificate, value) != 0)
1514 {
1515 LogError("unable to mallocAndStrcpy_s %s", optionName);
1516 result = MU_FAILURE;
1517 }
1518 else
1519 {
1520 result = 0;
1521 }
1522 }
1523 }
1524 else if (strcmp("ignore_server_name_check", optionName) == 0)
1525 {
1526 bool* server_name_check = (bool*)value;
1527 tls_io_instance->ignore_server_name_check = *server_name_check;
1528 result = 0;
1529 }
1530 else if (tls_io_instance->socket_io == NULL)
1531 {
1532 LogError("tls_io_instance->socket_io is not set");
1533 result = MU_FAILURE;
1534 }
1535 else if (strcmp(optionName, OPTION_SET_TLS_RENEGOTIATION) == 0)
1536 {
1537 // No need to do anything for Schannel
1538 result = 0;
1539 }
1540 else
1541 {
1542 result = xio_setoption(tls_io_instance->socket_io, optionName, value);
1543 }
1544 }
1545
1546 return result;
1547 }
1548
1549 const IO_INTERFACE_DESCRIPTION* tlsio_schannel_get_interface_description(void)
1550 {
1551 return &tlsio_schannel_interface_description;
1552 }