1/***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) 2012 - 2021, Daniel Stenberg, <daniel@haxx.se>, et al.
9 * Copyright (C) 2009, 2011, Markus Moeller, <markus_moeller@compuserve.com>
10 *
11 * This software is licensed as described in the file COPYING, which
12 * you should have received as part of this distribution. The terms
13 * are also available at https://curl.se/docs/copyright.html.
14 *
15 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
16 * copies of the Software, and permit persons to whom the Software is
17 * furnished to do so, under the terms of the COPYING file.
18 *
19 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
20 * KIND, either express or implied.
21 *
22 ***************************************************************************/
23
24#include "curl_setup.h"
25
26#if defined(USE_WINDOWS_SSPI) && !defined(CURL_DISABLE_PROXY)
27
28#include "urldata.h"
29#include "sendf.h"
30#include "connect.h"
31#include "strerror.h"
32#include "timeval.h"
33#include "socks.h"
34#include "curl_sspi.h"
35#include "curl_multibyte.h"
36#include "warnless.h"
37#include "strdup.h"
38/* The last 3 #include files should be in this order */
39#include "curl_printf.h"
40#include "curl_memory.h"
41#include "memdebug.h"
42
43/*
44 * Helper sspi error functions.
45 */
46static int check_sspi_err(struct Curl_easy *data,
47 SECURITY_STATUS status,
48 const char *function)
49{
50 if(status != SEC_E_OK &&
51 status != SEC_I_COMPLETE_AND_CONTINUE &&
52 status != SEC_I_COMPLETE_NEEDED &&
53 status != SEC_I_CONTINUE_NEEDED) {
54 char buffer[STRERROR_LEN];
55 failf(data, "SSPI error: %s failed: %s", function,
56 Curl_sspi_strerror(status, buffer, sizeof(buffer)));
57 return 1;
58 }
59 return 0;
60}
61
62/* This is the SSPI-using version of this function */
63CURLcode Curl_SOCKS5_gssapi_negotiate(int sockindex,
64 struct Curl_easy *data)
65{
66 struct connectdata *conn = data->conn;
67 curl_socket_t sock = conn->sock[sockindex];
68 CURLcode code;
69 ssize_t actualread;
70 ssize_t written;
71 int result;
72 /* Needs GSS-API authentication */
73 SECURITY_STATUS status;
74 unsigned long sspi_ret_flags = 0;
75 unsigned char gss_enc;
76 SecBuffer sspi_send_token, sspi_recv_token, sspi_w_token[3];
77 SecBufferDesc input_desc, output_desc, wrap_desc;
78 SecPkgContext_Sizes sspi_sizes;
79 CredHandle cred_handle;
80 CtxtHandle sspi_context;
81 PCtxtHandle context_handle = NULL;
82 SecPkgCredentials_Names names;
83 TimeStamp expiry;
84 char *service_name = NULL;
85 unsigned short us_length;
86 unsigned long qop;
87 unsigned char socksreq[4]; /* room for GSS-API exchange header only */
88 const char *service = data->set.str[STRING_PROXY_SERVICE_NAME] ?
89 data->set.str[STRING_PROXY_SERVICE_NAME] : "rcmd";
90 const size_t service_length = strlen(service);
91
92 /* GSS-API request looks like
93 * +----+------+-----+----------------+
94 * |VER | MTYP | LEN | TOKEN |
95 * +----+------+----------------------+
96 * | 1 | 1 | 2 | up to 2^16 - 1 |
97 * +----+------+-----+----------------+
98 */
99
100 /* prepare service name */
101 if(strchr(service, '/')) {
102 service_name = strdup(service);
103 if(!service_name)
104 return CURLE_OUT_OF_MEMORY;
105 }
106 else {
107 service_name = malloc(service_length +
108 strlen(conn->socks_proxy.host.name) + 2);
109 if(!service_name)
110 return CURLE_OUT_OF_MEMORY;
111 msnprintf(service_name, service_length +
112 strlen(conn->socks_proxy.host.name) + 2, "%s/%s",
113 service, conn->socks_proxy.host.name);
114 }
115
116 input_desc.cBuffers = 1;
117 input_desc.pBuffers = &sspi_recv_token;
118 input_desc.ulVersion = SECBUFFER_VERSION;
119
120 sspi_recv_token.BufferType = SECBUFFER_TOKEN;
121 sspi_recv_token.cbBuffer = 0;
122 sspi_recv_token.pvBuffer = NULL;
123
124 output_desc.cBuffers = 1;
125 output_desc.pBuffers = &sspi_send_token;
126 output_desc.ulVersion = SECBUFFER_VERSION;
127
128 sspi_send_token.BufferType = SECBUFFER_TOKEN;
129 sspi_send_token.cbBuffer = 0;
130 sspi_send_token.pvBuffer = NULL;
131
132 wrap_desc.cBuffers = 3;
133 wrap_desc.pBuffers = sspi_w_token;
134 wrap_desc.ulVersion = SECBUFFER_VERSION;
135
136 cred_handle.dwLower = 0;
137 cred_handle.dwUpper = 0;
138
139 status = s_pSecFn->AcquireCredentialsHandle(NULL,
140 (TCHAR *) TEXT("Kerberos"),
141 SECPKG_CRED_OUTBOUND,
142 NULL,
143 NULL,
144 NULL,
145 NULL,
146 &cred_handle,
147 &expiry);
148
149 if(check_sspi_err(data, status, "AcquireCredentialsHandle")) {
150 failf(data, "Failed to acquire credentials.");
151 free(service_name);
152 s_pSecFn->FreeCredentialsHandle(&cred_handle);
153 return CURLE_COULDNT_CONNECT;
154 }
155
156 (void)curlx_nonblock(sock, FALSE);
157
158 /* As long as we need to keep sending some context info, and there's no */
159 /* errors, keep sending it... */
160 for(;;) {
161 TCHAR *sname;
162
163 sname = curlx_convert_UTF8_to_tchar(service_name);
164 if(!sname)
165 return CURLE_OUT_OF_MEMORY;
166
167 status = s_pSecFn->InitializeSecurityContext(&cred_handle,
168 context_handle,
169 sname,
170 ISC_REQ_MUTUAL_AUTH |
171 ISC_REQ_ALLOCATE_MEMORY |
172 ISC_REQ_CONFIDENTIALITY |
173 ISC_REQ_REPLAY_DETECT,
174 0,
175 SECURITY_NATIVE_DREP,
176 &input_desc,
177 0,
178 &sspi_context,
179 &output_desc,
180 &sspi_ret_flags,
181 &expiry);
182
183 curlx_unicodefree(sname);
184
185 if(sspi_recv_token.pvBuffer) {
186 s_pSecFn->FreeContextBuffer(sspi_recv_token.pvBuffer);
187 sspi_recv_token.pvBuffer = NULL;
188 sspi_recv_token.cbBuffer = 0;
189 }
190
191 if(check_sspi_err(data, status, "InitializeSecurityContext")) {
192 free(service_name);
193 s_pSecFn->FreeCredentialsHandle(&cred_handle);
194 s_pSecFn->DeleteSecurityContext(&sspi_context);
195 if(sspi_recv_token.pvBuffer)
196 s_pSecFn->FreeContextBuffer(sspi_recv_token.pvBuffer);
197 failf(data, "Failed to initialise security context.");
198 return CURLE_COULDNT_CONNECT;
199 }
200
201 if(sspi_send_token.cbBuffer) {
202 socksreq[0] = 1; /* GSS-API subnegotiation version */
203 socksreq[1] = 1; /* authentication message type */
204 us_length = htons((short)sspi_send_token.cbBuffer);
205 memcpy(socksreq + 2, &us_length, sizeof(short));
206
207 code = Curl_write_plain(data, sock, (char *)socksreq, 4, &written);
208 if(code || (4 != written)) {
209 failf(data, "Failed to send SSPI authentication request.");
210 free(service_name);
211 if(sspi_send_token.pvBuffer)
212 s_pSecFn->FreeContextBuffer(sspi_send_token.pvBuffer);
213 if(sspi_recv_token.pvBuffer)
214 s_pSecFn->FreeContextBuffer(sspi_recv_token.pvBuffer);
215 s_pSecFn->FreeCredentialsHandle(&cred_handle);
216 s_pSecFn->DeleteSecurityContext(&sspi_context);
217 return CURLE_COULDNT_CONNECT;
218 }
219
220 code = Curl_write_plain(data, sock, (char *)sspi_send_token.pvBuffer,
221 sspi_send_token.cbBuffer, &written);
222 if(code || (sspi_send_token.cbBuffer != (size_t)written)) {
223 failf(data, "Failed to send SSPI authentication token.");
224 free(service_name);
225 if(sspi_send_token.pvBuffer)
226 s_pSecFn->FreeContextBuffer(sspi_send_token.pvBuffer);
227 if(sspi_recv_token.pvBuffer)
228 s_pSecFn->FreeContextBuffer(sspi_recv_token.pvBuffer);
229 s_pSecFn->FreeCredentialsHandle(&cred_handle);
230 s_pSecFn->DeleteSecurityContext(&sspi_context);
231 return CURLE_COULDNT_CONNECT;
232 }
233
234 }
235
236 if(sspi_send_token.pvBuffer) {
237 s_pSecFn->FreeContextBuffer(sspi_send_token.pvBuffer);
238 sspi_send_token.pvBuffer = NULL;
239 }
240 sspi_send_token.cbBuffer = 0;
241
242 if(sspi_recv_token.pvBuffer) {
243 s_pSecFn->FreeContextBuffer(sspi_recv_token.pvBuffer);
244 sspi_recv_token.pvBuffer = NULL;
245 }
246 sspi_recv_token.cbBuffer = 0;
247
248 if(status != SEC_I_CONTINUE_NEEDED)
249 break;
250
251 /* analyse response */
252
253 /* GSS-API response looks like
254 * +----+------+-----+----------------+
255 * |VER | MTYP | LEN | TOKEN |
256 * +----+------+----------------------+
257 * | 1 | 1 | 2 | up to 2^16 - 1 |
258 * +----+------+-----+----------------+
259 */
260
261 result = Curl_blockread_all(data, sock, (char *)socksreq, 4, &actualread);
262 if(result || (actualread != 4)) {
263 failf(data, "Failed to receive SSPI authentication response.");
264 free(service_name);
265 s_pSecFn->FreeCredentialsHandle(&cred_handle);
266 s_pSecFn->DeleteSecurityContext(&sspi_context);
267 return CURLE_COULDNT_CONNECT;
268 }
269
270 /* ignore the first (VER) byte */
271 if(socksreq[1] == 255) { /* status / message type */
272 failf(data, "User was rejected by the SOCKS5 server (%u %u).",
273 (unsigned int)socksreq[0], (unsigned int)socksreq[1]);
274 free(service_name);
275 s_pSecFn->FreeCredentialsHandle(&cred_handle);
276 s_pSecFn->DeleteSecurityContext(&sspi_context);
277 return CURLE_COULDNT_CONNECT;
278 }
279
280 if(socksreq[1] != 1) { /* status / messgae type */
281 failf(data, "Invalid SSPI authentication response type (%u %u).",
282 (unsigned int)socksreq[0], (unsigned int)socksreq[1]);
283 free(service_name);
284 s_pSecFn->FreeCredentialsHandle(&cred_handle);
285 s_pSecFn->DeleteSecurityContext(&sspi_context);
286 return CURLE_COULDNT_CONNECT;
287 }
288
289 memcpy(&us_length, socksreq + 2, sizeof(short));
290 us_length = ntohs(us_length);
291
292 sspi_recv_token.cbBuffer = us_length;
293 sspi_recv_token.pvBuffer = malloc(us_length);
294
295 if(!sspi_recv_token.pvBuffer) {
296 free(service_name);
297 s_pSecFn->FreeCredentialsHandle(&cred_handle);
298 s_pSecFn->DeleteSecurityContext(&sspi_context);
299 return CURLE_OUT_OF_MEMORY;
300 }
301 result = Curl_blockread_all(data, sock, (char *)sspi_recv_token.pvBuffer,
302 sspi_recv_token.cbBuffer, &actualread);
303
304 if(result || (actualread != us_length)) {
305 failf(data, "Failed to receive SSPI authentication token.");
306 free(service_name);
307 if(sspi_recv_token.pvBuffer)
308 s_pSecFn->FreeContextBuffer(sspi_recv_token.pvBuffer);
309 s_pSecFn->FreeCredentialsHandle(&cred_handle);
310 s_pSecFn->DeleteSecurityContext(&sspi_context);
311 return CURLE_COULDNT_CONNECT;
312 }
313
314 context_handle = &sspi_context;
315 }
316
317 free(service_name);
318
319 /* Everything is good so far, user was authenticated! */
320 status = s_pSecFn->QueryCredentialsAttributes(&cred_handle,
321 SECPKG_CRED_ATTR_NAMES,
322 &names);
323 s_pSecFn->FreeCredentialsHandle(&cred_handle);
324 if(check_sspi_err(data, status, "QueryCredentialAttributes")) {
325 s_pSecFn->DeleteSecurityContext(&sspi_context);
326 s_pSecFn->FreeContextBuffer(names.sUserName);
327 failf(data, "Failed to determine user name.");
328 return CURLE_COULDNT_CONNECT;
329 }
330 infof(data, "SOCKS5 server authenticated user %s with GSS-API.",
331 names.sUserName);
332 s_pSecFn->FreeContextBuffer(names.sUserName);
333
334 /* Do encryption */
335 socksreq[0] = 1; /* GSS-API subnegotiation version */
336 socksreq[1] = 2; /* encryption message type */
337
338 gss_enc = 0; /* no data protection */
339 /* do confidentiality protection if supported */
340 if(sspi_ret_flags & ISC_REQ_CONFIDENTIALITY)
341 gss_enc = 2;
342 /* else do integrity protection */
343 else if(sspi_ret_flags & ISC_REQ_INTEGRITY)
344 gss_enc = 1;
345
346 infof(data, "SOCKS5 server supports GSS-API %s data protection.",
347 (gss_enc == 0)?"no":((gss_enc == 1)?"integrity":"confidentiality") );
348 /* force to no data protection, avoid encryption/decryption for now */
349 gss_enc = 0;
350 /*
351 * Sending the encryption type in clear seems wrong. It should be
352 * protected with gss_seal()/gss_wrap(). See RFC1961 extract below
353 * The NEC reference implementations on which this is based is
354 * therefore at fault
355 *
356 * +------+------+------+.......................+
357 * + ver | mtyp | len | token |
358 * +------+------+------+.......................+
359 * + 0x01 | 0x02 | 0x02 | up to 2^16 - 1 octets |
360 * +------+------+------+.......................+
361 *
362 * Where:
363 *
364 * - "ver" is the protocol version number, here 1 to represent the
365 * first version of the SOCKS/GSS-API protocol
366 *
367 * - "mtyp" is the message type, here 2 to represent a protection
368 * -level negotiation message
369 *
370 * - "len" is the length of the "token" field in octets
371 *
372 * - "token" is the GSS-API encapsulated protection level
373 *
374 * The token is produced by encapsulating an octet containing the
375 * required protection level using gss_seal()/gss_wrap() with conf_req
376 * set to FALSE. The token is verified using gss_unseal()/
377 * gss_unwrap().
378 *
379 */
380
381 if(data->set.socks5_gssapi_nec) {
382 us_length = htons((short)1);
383 memcpy(socksreq + 2, &us_length, sizeof(short));
384 }
385 else {
386 status = s_pSecFn->QueryContextAttributes(&sspi_context,
387 SECPKG_ATTR_SIZES,
388 &sspi_sizes);
389 if(check_sspi_err(data, status, "QueryContextAttributes")) {
390 s_pSecFn->DeleteSecurityContext(&sspi_context);
391 failf(data, "Failed to query security context attributes.");
392 return CURLE_COULDNT_CONNECT;
393 }
394
395 sspi_w_token[0].cbBuffer = sspi_sizes.cbSecurityTrailer;
396 sspi_w_token[0].BufferType = SECBUFFER_TOKEN;
397 sspi_w_token[0].pvBuffer = malloc(sspi_sizes.cbSecurityTrailer);
398
399 if(!sspi_w_token[0].pvBuffer) {
400 s_pSecFn->DeleteSecurityContext(&sspi_context);
401 return CURLE_OUT_OF_MEMORY;
402 }
403
404 sspi_w_token[1].cbBuffer = 1;
405 sspi_w_token[1].pvBuffer = malloc(1);
406 if(!sspi_w_token[1].pvBuffer) {
407 s_pSecFn->FreeContextBuffer(sspi_w_token[0].pvBuffer);
408 s_pSecFn->DeleteSecurityContext(&sspi_context);
409 return CURLE_OUT_OF_MEMORY;
410 }
411
412 memcpy(sspi_w_token[1].pvBuffer, &gss_enc, 1);
413 sspi_w_token[2].BufferType = SECBUFFER_PADDING;
414 sspi_w_token[2].cbBuffer = sspi_sizes.cbBlockSize;
415 sspi_w_token[2].pvBuffer = malloc(sspi_sizes.cbBlockSize);
416 if(!sspi_w_token[2].pvBuffer) {
417 s_pSecFn->FreeContextBuffer(sspi_w_token[0].pvBuffer);
418 s_pSecFn->FreeContextBuffer(sspi_w_token[1].pvBuffer);
419 s_pSecFn->DeleteSecurityContext(&sspi_context);
420 return CURLE_OUT_OF_MEMORY;
421 }
422 status = s_pSecFn->EncryptMessage(&sspi_context,
423 KERB_WRAP_NO_ENCRYPT,
424 &wrap_desc,
425 0);
426 if(check_sspi_err(data, status, "EncryptMessage")) {
427 s_pSecFn->FreeContextBuffer(sspi_w_token[0].pvBuffer);
428 s_pSecFn->FreeContextBuffer(sspi_w_token[1].pvBuffer);
429 s_pSecFn->FreeContextBuffer(sspi_w_token[2].pvBuffer);
430 s_pSecFn->DeleteSecurityContext(&sspi_context);
431 failf(data, "Failed to query security context attributes.");
432 return CURLE_COULDNT_CONNECT;
433 }
434 sspi_send_token.cbBuffer = sspi_w_token[0].cbBuffer
435 + sspi_w_token[1].cbBuffer
436 + sspi_w_token[2].cbBuffer;
437 sspi_send_token.pvBuffer = malloc(sspi_send_token.cbBuffer);
438 if(!sspi_send_token.pvBuffer) {
439 s_pSecFn->FreeContextBuffer(sspi_w_token[0].pvBuffer);
440 s_pSecFn->FreeContextBuffer(sspi_w_token[1].pvBuffer);
441 s_pSecFn->FreeContextBuffer(sspi_w_token[2].pvBuffer);
442 s_pSecFn->DeleteSecurityContext(&sspi_context);
443 return CURLE_OUT_OF_MEMORY;
444 }
445
446 memcpy(sspi_send_token.pvBuffer, sspi_w_token[0].pvBuffer,
447 sspi_w_token[0].cbBuffer);
448 memcpy((PUCHAR) sspi_send_token.pvBuffer +(int)sspi_w_token[0].cbBuffer,
449 sspi_w_token[1].pvBuffer, sspi_w_token[1].cbBuffer);
450 memcpy((PUCHAR) sspi_send_token.pvBuffer
451 + sspi_w_token[0].cbBuffer
452 + sspi_w_token[1].cbBuffer,
453 sspi_w_token[2].pvBuffer, sspi_w_token[2].cbBuffer);
454
455 s_pSecFn->FreeContextBuffer(sspi_w_token[0].pvBuffer);
456 sspi_w_token[0].pvBuffer = NULL;
457 sspi_w_token[0].cbBuffer = 0;
458 s_pSecFn->FreeContextBuffer(sspi_w_token[1].pvBuffer);
459 sspi_w_token[1].pvBuffer = NULL;
460 sspi_w_token[1].cbBuffer = 0;
461 s_pSecFn->FreeContextBuffer(sspi_w_token[2].pvBuffer);
462 sspi_w_token[2].pvBuffer = NULL;
463 sspi_w_token[2].cbBuffer = 0;
464
465 us_length = htons((short)sspi_send_token.cbBuffer);
466 memcpy(socksreq + 2, &us_length, sizeof(short));
467 }
468
469 code = Curl_write_plain(data, sock, (char *)socksreq, 4, &written);
470 if(code || (4 != written)) {
471 failf(data, "Failed to send SSPI encryption request.");
472 if(sspi_send_token.pvBuffer)
473 s_pSecFn->FreeContextBuffer(sspi_send_token.pvBuffer);
474 s_pSecFn->DeleteSecurityContext(&sspi_context);
475 return CURLE_COULDNT_CONNECT;
476 }
477
478 if(data->set.socks5_gssapi_nec) {
479 memcpy(socksreq, &gss_enc, 1);
480 code = Curl_write_plain(data, sock, (char *)socksreq, 1, &written);
481 if(code || (1 != written)) {
482 failf(data, "Failed to send SSPI encryption type.");
483 s_pSecFn->DeleteSecurityContext(&sspi_context);
484 return CURLE_COULDNT_CONNECT;
485 }
486 }
487 else {
488 code = Curl_write_plain(data, sock, (char *)sspi_send_token.pvBuffer,
489 sspi_send_token.cbBuffer, &written);
490 if(code || (sspi_send_token.cbBuffer != (size_t)written)) {
491 failf(data, "Failed to send SSPI encryption type.");
492 if(sspi_send_token.pvBuffer)
493 s_pSecFn->FreeContextBuffer(sspi_send_token.pvBuffer);
494 s_pSecFn->DeleteSecurityContext(&sspi_context);
495 return CURLE_COULDNT_CONNECT;
496 }
497 if(sspi_send_token.pvBuffer)
498 s_pSecFn->FreeContextBuffer(sspi_send_token.pvBuffer);
499 }
500
501 result = Curl_blockread_all(data, sock, (char *)socksreq, 4, &actualread);
502 if(result || (actualread != 4)) {
503 failf(data, "Failed to receive SSPI encryption response.");
504 s_pSecFn->DeleteSecurityContext(&sspi_context);
505 return CURLE_COULDNT_CONNECT;
506 }
507
508 /* ignore the first (VER) byte */
509 if(socksreq[1] == 255) { /* status / message type */
510 failf(data, "User was rejected by the SOCKS5 server (%u %u).",
511 (unsigned int)socksreq[0], (unsigned int)socksreq[1]);
512 s_pSecFn->DeleteSecurityContext(&sspi_context);
513 return CURLE_COULDNT_CONNECT;
514 }
515
516 if(socksreq[1] != 2) { /* status / message type */
517 failf(data, "Invalid SSPI encryption response type (%u %u).",
518 (unsigned int)socksreq[0], (unsigned int)socksreq[1]);
519 s_pSecFn->DeleteSecurityContext(&sspi_context);
520 return CURLE_COULDNT_CONNECT;
521 }
522
523 memcpy(&us_length, socksreq + 2, sizeof(short));
524 us_length = ntohs(us_length);
525
526 sspi_w_token[0].cbBuffer = us_length;
527 sspi_w_token[0].pvBuffer = malloc(us_length);
528 if(!sspi_w_token[0].pvBuffer) {
529 s_pSecFn->DeleteSecurityContext(&sspi_context);
530 return CURLE_OUT_OF_MEMORY;
531 }
532
533 result = Curl_blockread_all(data, sock, (char *)sspi_w_token[0].pvBuffer,
534 sspi_w_token[0].cbBuffer, &actualread);
535
536 if(result || (actualread != us_length)) {
537 failf(data, "Failed to receive SSPI encryption type.");
538 s_pSecFn->FreeContextBuffer(sspi_w_token[0].pvBuffer);
539 s_pSecFn->DeleteSecurityContext(&sspi_context);
540 return CURLE_COULDNT_CONNECT;
541 }
542
543
544 if(!data->set.socks5_gssapi_nec) {
545 wrap_desc.cBuffers = 2;
546 sspi_w_token[0].BufferType = SECBUFFER_STREAM;
547 sspi_w_token[1].BufferType = SECBUFFER_DATA;
548 sspi_w_token[1].cbBuffer = 0;
549 sspi_w_token[1].pvBuffer = NULL;
550
551 status = s_pSecFn->DecryptMessage(&sspi_context,
552 &wrap_desc,
553 0,
554 &qop);
555
556 if(check_sspi_err(data, status, "DecryptMessage")) {
557 if(sspi_w_token[0].pvBuffer)
558 s_pSecFn->FreeContextBuffer(sspi_w_token[0].pvBuffer);
559 if(sspi_w_token[1].pvBuffer)
560 s_pSecFn->FreeContextBuffer(sspi_w_token[1].pvBuffer);
561 s_pSecFn->DeleteSecurityContext(&sspi_context);
562 failf(data, "Failed to query security context attributes.");
563 return CURLE_COULDNT_CONNECT;
564 }
565
566 if(sspi_w_token[1].cbBuffer != 1) {
567 failf(data, "Invalid SSPI encryption response length (%lu).",
568 (unsigned long)sspi_w_token[1].cbBuffer);
569 if(sspi_w_token[0].pvBuffer)
570 s_pSecFn->FreeContextBuffer(sspi_w_token[0].pvBuffer);
571 if(sspi_w_token[1].pvBuffer)
572 s_pSecFn->FreeContextBuffer(sspi_w_token[1].pvBuffer);
573 s_pSecFn->DeleteSecurityContext(&sspi_context);
574 return CURLE_COULDNT_CONNECT;
575 }
576
577 memcpy(socksreq, sspi_w_token[1].pvBuffer, sspi_w_token[1].cbBuffer);
578 s_pSecFn->FreeContextBuffer(sspi_w_token[0].pvBuffer);
579 s_pSecFn->FreeContextBuffer(sspi_w_token[1].pvBuffer);
580 }
581 else {
582 if(sspi_w_token[0].cbBuffer != 1) {
583 failf(data, "Invalid SSPI encryption response length (%lu).",
584 (unsigned long)sspi_w_token[0].cbBuffer);
585 s_pSecFn->FreeContextBuffer(sspi_w_token[0].pvBuffer);
586 s_pSecFn->DeleteSecurityContext(&sspi_context);
587 return CURLE_COULDNT_CONNECT;
588 }
589 memcpy(socksreq, sspi_w_token[0].pvBuffer, sspi_w_token[0].cbBuffer);
590 s_pSecFn->FreeContextBuffer(sspi_w_token[0].pvBuffer);
591 }
592 (void)curlx_nonblock(sock, TRUE);
593
594 infof(data, "SOCKS5 access with%s protection granted.",
595 (socksreq[0] == 0)?"out GSS-API data":
596 ((socksreq[0] == 1)?" GSS-API integrity":" GSS-API confidentiality"));
597
598 /* For later use if encryption is required
599 conn->socks5_gssapi_enctype = socksreq[0];
600 if(socksreq[0] != 0)
601 conn->socks5_sspi_context = sspi_context;
602 else {
603 s_pSecFn->DeleteSecurityContext(&sspi_context);
604 conn->socks5_sspi_context = sspi_context;
605 }
606 */
607 return CURLE_OK;
608}
609#endif
610