?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
shdocvw: Move connection points to DocHost object.
[wine.git] / dlls / secur32 / ntlm.c
blob86aa0b66d30409be37421813f02c4101d9275a44
1 /*
2 * Copyright 2005 Kai Blin
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 *
18 * This file implements the NTLM security provider.
19 */
20
21 #include <assert.h>
22 #include <stdarg.h>
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winnls.h"
26 #include "rpc.h"
27 #include "sspi.h"
28 #include "lm.h"
29 #include "secur32_priv.h"
30 #include "wine/debug.h"
31
32 WINE_DEFAULT_DEBUG_CHANNEL(secur32);
33
34 #define NTLM_MAX_BUF 2010
35
36 static char ntlm_name_A[] = "NTLM";
37 static WCHAR ntlm_name_W[] = {'N', 'T', 'L', 'M', 0};
38
39
40 /***********************************************************************
41 * QueryCredentialsAttributesA
42 */
43 static SECURITY_STATUS SEC_ENTRY ntlm_QueryCredentialsAttributesA(
44 PCredHandle phCredential, ULONG ulAttribute, PVOID pBuffer)
45 {
46 SECURITY_STATUS ret;
47
48 TRACE("(%p, %ld, %p)\n", phCredential, ulAttribute, pBuffer);
49
50 if(ulAttribute == SECPKG_ATTR_NAMES)
51 {
52 FIXME("SECPKG_CRED_ATTR_NAMES: stub\n");
53 ret = SEC_E_UNSUPPORTED_FUNCTION;
54 }
55 else
56 ret = SEC_E_UNSUPPORTED_FUNCTION;
57
58 return ret;
59 }
60
61 /***********************************************************************
62 * QueryCredentialsAttributesW
63 */
64 static SECURITY_STATUS SEC_ENTRY ntlm_QueryCredentialsAttributesW(
65 PCredHandle phCredential, ULONG ulAttribute, PVOID pBuffer)
66 {
67 SECURITY_STATUS ret;
68
69 TRACE("(%p, %ld, %p)\n", phCredential, ulAttribute, pBuffer);
70
71 if(ulAttribute == SECPKG_ATTR_NAMES)
72 {
73 FIXME("SECPKG_CRED_ATTR_NAMES: stub\n");
74 ret = SEC_E_UNSUPPORTED_FUNCTION;
75 }
76 else
77 ret = SEC_E_UNSUPPORTED_FUNCTION;
78
79 return ret;
80 }
81
82 /***********************************************************************
83 * AcquireCredentialsHandleW
84 */
85 static SECURITY_STATUS SEC_ENTRY ntlm_AcquireCredentialsHandleW(
86 SEC_WCHAR *pszPrincipal, SEC_WCHAR *pszPackage, ULONG fCredentialUse,
87 PLUID pLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn,
88 PVOID pGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry)
89 {
90 SECURITY_STATUS ret;
91 PNegoHelper helper = NULL;
92
93 SEC_CHAR *client_user_arg = NULL;
94 SEC_CHAR *client_domain_arg = NULL;
95 SEC_WCHAR *username = NULL, *domain = NULL;
96
97 SEC_CHAR *client_argv[5];
98 SEC_CHAR *server_argv[] = { "ntlm_auth",
99 "--helper-protocol=squid-2.5-ntlmssp",
100 NULL };
101
102 TRACE("(%s, %s, 0x%08lx, %p, %p, %p, %p, %p, %p)\n",
103 debugstr_w(pszPrincipal), debugstr_w(pszPackage), fCredentialUse,
104 pLogonID, pAuthData, pGetKeyFn, pGetKeyArgument, phCredential, ptsExpiry);
105
106
107 switch(fCredentialUse)
108 {
109 case SECPKG_CRED_INBOUND:
110 if( (ret = fork_helper(&helper, "ntlm_auth", server_argv)) !=
111 SEC_E_OK)
112 {
113 phCredential = NULL;
114 break;
115 }
116 else
117 {
118 helper->mode = NTLM_SERVER;
119 phCredential->dwUpper = fCredentialUse;
120 phCredential->dwLower = (DWORD)helper;
121 }
122 ret = SEC_E_OK;
123 break;
124 case SECPKG_CRED_OUTBOUND:
125 {
126 static const char username_arg[] = "--username=";
127 static const char domain_arg[] = "--domain=";
128 int unixcp_size;
129
130 if(pAuthData == NULL)
131 {
132 LPWKSTA_USER_INFO_1 ui = NULL;
133 NET_API_STATUS status;
134
135 if((status = NetWkstaUserGetInfo(NULL, 1, (LPBYTE *)&ui)) !=
136 NERR_Success)
137 {
138 ret = SEC_E_NO_CREDENTIALS;
139 phCredential = NULL;
140 break;
141 }
142
143 if(ui != NULL)
144 {
145 username = HeapAlloc(GetProcessHeap(), 0,
146 (lstrlenW(ui->wkui1_username)+1) *
147 sizeof(SEC_WCHAR));
148 lstrcpyW(username, ui->wkui1_username);
149
150 /* same for the domain */
151 domain = HeapAlloc(GetProcessHeap(), 0,
152 (lstrlenW(ui->wkui1_logon_domain)+1) *
153 sizeof(SEC_WCHAR));
154 lstrcpyW(domain, ui->wkui1_logon_domain);
155 NetApiBufferFree(ui);
156 }
157 else
158 {
159 ret = SEC_E_NO_CREDENTIALS;
160 phCredential = NULL;
161 break;
162 }
163
164
165 }
166 else
167 {
168 PSEC_WINNT_AUTH_IDENTITY_W auth_data =
169 (PSEC_WINNT_AUTH_IDENTITY_W)pAuthData;
170
171 if(auth_data->UserLength != 0)
172 {
173 /* Get username and domain from pAuthData */
174 username = HeapAlloc(GetProcessHeap(), 0,
175 (auth_data->UserLength + 1) * sizeof(SEC_WCHAR));
176 lstrcpyW(username, auth_data->User);
177 }
178 else
179 {
180 ret = SEC_E_NO_CREDENTIALS;
181 phCredential = NULL;
182 break;
183 }
184 if(auth_data->DomainLength != 0)
185 {
186 domain = HeapAlloc(GetProcessHeap(), 0,
187 (auth_data->DomainLength + 1) * sizeof(SEC_WCHAR));
188 lstrcpyW(domain, auth_data->Domain);
189
190 }
191 else
192 {
193 ret = SEC_E_NO_CREDENTIALS;
194 phCredential = NULL;
195 break;
196 }
197
198 }
199 TRACE("Username is %s\n", debugstr_w(username));
200 unixcp_size = WideCharToMultiByte(CP_UNIXCP, WC_NO_BEST_FIT_CHARS,
201 username, -1, NULL, 0, NULL, NULL) + sizeof(username_arg);
202 client_user_arg = HeapAlloc(GetProcessHeap(), 0, unixcp_size);
203 lstrcpyA(client_user_arg, username_arg);
204 WideCharToMultiByte(CP_UNIXCP, WC_NO_BEST_FIT_CHARS, username, -1,
205 client_user_arg + sizeof(username_arg) - 1,
206 unixcp_size - sizeof(username_arg) + 1, NULL, NULL);
207
208 TRACE("Domain name is %s\n", debugstr_w(domain));
209 unixcp_size = WideCharToMultiByte(CP_UNIXCP, WC_NO_BEST_FIT_CHARS,
210 domain, -1, NULL, 0, NULL, NULL) + sizeof(domain_arg);
211 client_domain_arg = HeapAlloc(GetProcessHeap(), 0, unixcp_size);
212 lstrcpyA(client_domain_arg, domain_arg);
213 WideCharToMultiByte(CP_UNIXCP, WC_NO_BEST_FIT_CHARS, domain,
214 -1, client_domain_arg + sizeof(domain_arg) - 1,
215 unixcp_size - sizeof(domain) + 1, NULL, NULL);
216
217 client_argv[0] = "ntlm_auth";
218 client_argv[1] = "--helper-protocol=ntlmssp-client-1";
219 client_argv[2] = client_user_arg;
220 client_argv[3] = client_domain_arg;
221 client_argv[4] = NULL;
222
223 if((ret = fork_helper(&helper, "ntlm_auth", client_argv)) !=
224 SEC_E_OK)
225 {
226 phCredential = NULL;
227 break;
228 }
229 else
230 {
231 helper->mode = NTLM_CLIENT;
232
233 if(pAuthData != NULL)
234 {
235 PSEC_WINNT_AUTH_IDENTITY_W auth_data =
236 (PSEC_WINNT_AUTH_IDENTITY_W)pAuthData;
237
238 if(auth_data->PasswordLength != 0)
239 {
240 helper->pwlen = WideCharToMultiByte(CP_UNIXCP,
241 WC_NO_BEST_FIT_CHARS, auth_data->Password,
242 auth_data->PasswordLength+1, NULL, 0, NULL, NULL);
243
244 helper->password = HeapAlloc(GetProcessHeap(), 0,
245 helper->pwlen);
246
247 WideCharToMultiByte(CP_UNIXCP, WC_NO_BEST_FIT_CHARS,
248 auth_data->Password, auth_data->PasswordLength+1,
249 helper->password, helper->pwlen, NULL, NULL);
250 }
251 }
252
253 phCredential->dwUpper = fCredentialUse;
254 phCredential->dwLower = (DWORD)helper;
255 TRACE("ACH phCredential->dwUpper: 0x%08lx, dwLower: 0x%08lx\n",
256 phCredential->dwUpper, phCredential->dwLower);
257 }
258 ret = SEC_E_OK;
259 break;
260 }
261 case SECPKG_CRED_BOTH:
262 FIXME("AcquireCredentialsHandle: SECPKG_CRED_BOTH stub\n");
263 ret = SEC_E_UNSUPPORTED_FUNCTION;
264 phCredential = NULL;
265 break;
266 default:
267 phCredential = NULL;
268 ret = SEC_E_UNKNOWN_CREDENTIALS;
269 }
270
271
272 HeapFree(GetProcessHeap(), 0, client_user_arg);
273 HeapFree(GetProcessHeap(), 0, client_domain_arg);
274 HeapFree(GetProcessHeap(), 0, username);
275 HeapFree(GetProcessHeap(), 0, domain);
276
277 return ret;
278 }
279
280 /***********************************************************************
281 * AcquireCredentialsHandleA
282 */
283 static SECURITY_STATUS SEC_ENTRY ntlm_AcquireCredentialsHandleA(
284 SEC_CHAR *pszPrincipal, SEC_CHAR *pszPackage, ULONG fCredentialUse,
285 PLUID pLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn,
286 PVOID pGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry)
287 {
288 SECURITY_STATUS ret;
289 int user_sizeW, domain_sizeW, passwd_sizeW;
290
291 SEC_WCHAR *user = NULL, *domain = NULL, *passwd = NULL, *package = NULL;
292
293 PSEC_WINNT_AUTH_IDENTITY_W pAuthDataW = NULL;
294 PSEC_WINNT_AUTH_IDENTITY_A identity = NULL;
295
296 TRACE("(%s, %s, 0x%08lx, %p, %p, %p, %p, %p, %p)\n",
297 debugstr_a(pszPrincipal), debugstr_a(pszPackage), fCredentialUse,
298 pLogonID, pAuthData, pGetKeyFn, pGetKeyArgument, phCredential, ptsExpiry);
299
300 if(pszPackage != NULL)
301 {
302 int package_sizeW = MultiByteToWideChar(CP_ACP, 0, pszPackage, -1,
303 NULL, 0);
304
305 package = HeapAlloc(GetProcessHeap(), 0, package_sizeW *
306 sizeof(SEC_WCHAR));
307 MultiByteToWideChar(CP_ACP, 0, pszPackage, -1, package, package_sizeW);
308 }
309
310
311 if(pAuthData != NULL)
312 {
313 identity = (PSEC_WINNT_AUTH_IDENTITY_A)pAuthData;
314
315 if(identity->Flags == SEC_WINNT_AUTH_IDENTITY_ANSI)
316 {
317 pAuthDataW = HeapAlloc(GetProcessHeap(), 0,
318 sizeof(SEC_WINNT_AUTH_IDENTITY_W));
319
320 if(identity->UserLength != 0)
321 {
322 user_sizeW = MultiByteToWideChar(CP_ACP, 0,
323 (LPCSTR)identity->User, identity->UserLength+1, NULL, 0);
324 user = HeapAlloc(GetProcessHeap(), 0, user_sizeW *
325 sizeof(SEC_WCHAR));
326 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)identity->User,
327 identity->UserLength+1, user, user_sizeW);
328 }
329 else
330 {
331 user_sizeW = 0;
332 }
333
334 if(identity->DomainLength != 0)
335 {
336 domain_sizeW = MultiByteToWideChar(CP_ACP, 0,
337 (LPCSTR)identity->Domain, identity->DomainLength+1, NULL, 0);
338 domain = HeapAlloc(GetProcessHeap(), 0, domain_sizeW
339 * sizeof(SEC_WCHAR));
340 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)identity->Domain,
341 identity->DomainLength+1, domain, domain_sizeW);
342 }
343 else
344 {
345 domain_sizeW = 0;
346 }
347
348 if(identity->PasswordLength != 0)
349 {
350 passwd_sizeW = MultiByteToWideChar(CP_ACP, 0,
351 (LPCSTR)identity->Password, identity->PasswordLength+1,
352 NULL, 0);
353 passwd = HeapAlloc(GetProcessHeap(), 0, passwd_sizeW
354 * sizeof(SEC_WCHAR));
355 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)identity->Password,
356 identity->PasswordLength+1, passwd, passwd_sizeW);
357 }
358 else
359 {
360 passwd_sizeW = 0;
361 }
362
363 pAuthDataW->Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
364 pAuthDataW->User = user;
365 pAuthDataW->UserLength = user_sizeW;
366 pAuthDataW->Domain = domain;
367 pAuthDataW->DomainLength = domain_sizeW;
368 pAuthDataW->Password = passwd;
369 pAuthDataW->PasswordLength = passwd_sizeW;
370 }
371 else
372 {
373 pAuthDataW = (PSEC_WINNT_AUTH_IDENTITY_W)identity;
374 }
375 }
376
377 ret = ntlm_AcquireCredentialsHandleW(NULL, package, fCredentialUse,
378 pLogonID, pAuthDataW, pGetKeyFn, pGetKeyArgument, phCredential,
379 ptsExpiry);
380
381 HeapFree(GetProcessHeap(), 0, package);
382 HeapFree(GetProcessHeap(), 0, user);
383 HeapFree(GetProcessHeap(), 0, domain);
384 HeapFree(GetProcessHeap(), 0, passwd);
385 if(pAuthDataW != (PSEC_WINNT_AUTH_IDENTITY_W)identity)
386 HeapFree(GetProcessHeap(), 0, pAuthDataW);
387
388 return ret;
389 }
390
391 /***********************************************************************
392 * InitializeSecurityContextW
393 */
394 static SECURITY_STATUS SEC_ENTRY ntlm_InitializeSecurityContextW(
395 PCredHandle phCredential, PCtxtHandle phContext, SEC_WCHAR *pszTargetName,
396 ULONG fContextReq, ULONG Reserved1, ULONG TargetDataRep,
397 PSecBufferDesc pInput, ULONG Reserved2, PCtxtHandle phNewContext,
398 PSecBufferDesc pOutput, ULONG *pfContextAttr, PTimeStamp ptsExpiry)
399 {
400 SECURITY_STATUS ret;
401
402 TRACE("%p %p %s %ld %ld %ld %p %ld %p %p %p %p\n", phCredential, phContext,
403 debugstr_w(pszTargetName), fContextReq, Reserved1, TargetDataRep, pInput,
404 Reserved1, phNewContext, pOutput, pfContextAttr, ptsExpiry);
405
406 if(phCredential){
407 /* As the server side of sspi never calls this, make sure that
408 * the handler is a client handler.
409 */
410 PNegoHelper helper = (PNegoHelper)phCredential->dwLower;
411 ULONG ctxt_attr = 0;
412 if(helper->mode == NTLM_CLIENT)
413 {
414 /****************************************
415 * When communicating with the client, there can be the
416 * following reply packets:
417 * YR <base64 blob> should be sent to the server
418 * PW should be sent back to helper with
419 * base64 encoded password
420 * AF <base64 blob> client is done, blob should be
421 * sent to server with KK prefixed
422 * BH <char reason> something broke
423 */
424 BOOL first = FALSE;
425 /* The squid cache size is 2010 chars, and that's what ntlm_auth uses */
426 char* buffer = HeapAlloc(GetProcessHeap(), 0,
427 sizeof(char) * NTLM_MAX_BUF);
428 PBYTE bin = HeapAlloc(GetProcessHeap(), 0, sizeof(BYTE) *
429 NTLM_MAX_BUF);
430 int buffer_len, bin_len, max_len = NTLM_MAX_BUF;
431
432 if((phContext == NULL) && (pInput == NULL))
433 first = TRUE;
434 if (pszTargetName)
435 {
436 TRACE("According to a MS whitepaper pszTargetName is ignored.\n");
437 }
438 /* Handle all the flags */
439 if(fContextReq & ISC_REQ_ALLOCATE_MEMORY)
440 {
441 FIXME("InitializeSecurityContext(): ISC_REQ_ALLOCATE_MEMORY stub\n");
442 }
443 if(fContextReq & ISC_REQ_CONFIDENTIALITY)
444 {
445 FIXME("InitializeSecurityContext(): ISC_REQ_CONFIDENTIALITY stub\n");
446 }
447 if(fContextReq & ISC_REQ_CONNECTION)
448 {
449 /* This is default, so we'll enable it */
450 ctxt_attr |= ISC_RET_CONNECTION;
451 }
452 if(fContextReq & ISC_REQ_EXTENDED_ERROR)
453 {
454 FIXME("InitializeSecurityContext(): ISC_REQ_EXTENDED_ERROR stub\n");
455 }
456 if(fContextReq & ISC_REQ_INTEGRITY)
457 {
458 FIXME("InitializeSecurityContext(): ISC_REQ_INTEGRITY stub\n");
459 }
460 if(fContextReq & ISC_REQ_MUTUAL_AUTH)
461 {
462 FIXME("InitializeSecurityContext(): ISC_REQ_MUTUAL_AUTH stub\n");
463 }
464 if(fContextReq & ISC_REQ_REPLAY_DETECT)
465 {
466 FIXME("InitializeSecurityContext(): ISC_REQ_REPLAY_DETECT stub\n");
467 }
468 if(fContextReq & ISC_REQ_SEQUENCE_DETECT)
469 {
470 FIXME("InitializeSecurityContext(): ISC_REQ_SEQUENCE_DETECT stub\n");
471 }
472 if(fContextReq & ISC_REQ_STREAM)
473 {
474 FIXME("InitializeSecurityContext(): ISC_REQ_STREAM stub\n");
475 }
476 /* Done with the flags */
477 if(TargetDataRep == SECURITY_NETWORK_DREP){
478 FIXME("Don't know how to do SECURITY_NETWORK_DREP\n");
479 HeapFree(GetProcessHeap(), 0, buffer);
480 HeapFree(GetProcessHeap(), 0, bin);
481 return SEC_E_UNSUPPORTED_FUNCTION;
482 }
483
484 if(first)
485 {
486 TRACE("First time in ISC()\n");
487 /* Request a challenge request from ntlm_auth */
488 if(helper->password == NULL)
489 {
490 FIXME("Using empty password for now.\n");
491 lstrcpynA(buffer, "PW AA==", max_len-1);
492 }
493 else
494 {
495 lstrcpynA(buffer, "PW ", max_len-1);
496 if((ret = encodeBase64((unsigned char*)helper->password,
497 helper->pwlen-2, buffer+3,
498 max_len-3, &buffer_len)) != SEC_E_OK)
499 {
500 TRACE("Deleting password!\n");
501 memset(helper->password, 0, helper->pwlen-2);
502 HeapFree(GetProcessHeap(), 0, helper->password);
503 HeapFree(GetProcessHeap(), 0, buffer);
504 HeapFree(GetProcessHeap(), 0, bin);
505 return ret;
506 }
507
508 }
509
510 TRACE("Sending to helper: %s\n", debugstr_a(buffer));
511 if((ret = run_helper(helper, buffer, max_len, &buffer_len)) !=
512 SEC_E_OK)
513 {
514 HeapFree(GetProcessHeap(), 0, buffer);
515 HeapFree(GetProcessHeap(), 0, bin);
516 return ret;
517 }
518 TRACE("Helper returned %s\n", debugstr_a(buffer));
519 lstrcpynA(buffer, "YR", max_len-1);
520
521 if((ret = run_helper(helper, buffer, max_len, &buffer_len)) !=
522 SEC_E_OK)
523 {
524 HeapFree(GetProcessHeap(), 0, buffer);
525 HeapFree(GetProcessHeap(), 0, bin);
526 return ret;
527 }
528
529 TRACE("%s\n", buffer);
530
531 if(strncmp(buffer, "YR ", 3) != 0)
532 {
533
534 /* Something borked */
535 TRACE("Helper returned %c%c\n", buffer[0], buffer[1]);
536 HeapFree(GetProcessHeap(), 0, buffer);
537 HeapFree(GetProcessHeap(), 0, bin);
538 return SEC_E_INTERNAL_ERROR;
539 }
540 if((ret = decodeBase64(buffer+3, buffer_len-3, bin,
541 max_len-1, &bin_len)) != SEC_E_OK)
542 {
543 HeapFree(GetProcessHeap(), 0, buffer);
544 HeapFree(GetProcessHeap(), 0, bin);
545 return ret;
546 }
547
548 /* put the decoded client blob into the out buffer */
549 if(pOutput == NULL){
550 TRACE("pOutput is NULL\n");
551 HeapFree(GetProcessHeap(), 0, buffer);
552 HeapFree(GetProcessHeap(), 0, bin);
553 return SEC_E_INSUFFICIENT_MEMORY;
554 }
555
556 if(pOutput->cBuffers < 1)
557 {
558 TRACE("pOutput->cBuffers is %ld\n", pOutput->cBuffers);
559 HeapFree(GetProcessHeap(), 0, buffer);
560 HeapFree(GetProcessHeap(), 0, bin);
561 return SEC_E_INSUFFICIENT_MEMORY;
562 }
563 pOutput->pBuffers[0].cbBuffer = bin_len;
564 pOutput->pBuffers[0].BufferType = SECBUFFER_DATA;
565 memcpy(pOutput->pBuffers[0].pvBuffer, bin, bin_len);
566
567 ret = SEC_I_CONTINUE_NEEDED;
568 }
569 else
570 {
571 /* handle second call here */
572 /* encode server data to base64 */
573 if(pInput == NULL)
574 {
575 HeapFree(GetProcessHeap(), 0, buffer);
576 HeapFree(GetProcessHeap(), 0, bin);
577 return SEC_E_INCOMPLETE_MESSAGE;
578 }
579
580 if(pInput->cBuffers < 1)
581 {
582 HeapFree(GetProcessHeap(), 0, buffer);
583 HeapFree(GetProcessHeap(), 0, bin);
584 return SEC_E_INCOMPLETE_MESSAGE;
585 }
586
587 if(pInput->pBuffers[0].cbBuffer > max_len)
588 {
589 TRACE("pInput->pBuffers[0].cbBuffer is: %ld\n",
590 pInput->pBuffers[0].cbBuffer);
591 HeapFree(GetProcessHeap(), 0, buffer);
592 HeapFree(GetProcessHeap(), 0, bin);
593 return SEC_E_INVALID_TOKEN;
594 }
595 else
596 bin_len = pInput->pBuffers[0].cbBuffer;
597
598 memcpy(bin, pInput->pBuffers[0].pvBuffer, bin_len);
599
600 lstrcpynA(buffer, "TT ", max_len-1);
601
602 if((ret = encodeBase64(bin, bin_len, buffer+3,
603 max_len-3, &buffer_len)) != SEC_E_OK)
604 {
605 HeapFree(GetProcessHeap(), 0, buffer);
606 HeapFree(GetProcessHeap(), 0, bin);
607 return ret;
608 }
609
610 TRACE("Server sent: %s\n", debugstr_a(buffer));
611
612 /* send TT base64 blob to ntlm_auth */
613 if((ret = run_helper(helper, buffer, max_len, &buffer_len)) !=
614 SEC_E_OK)
615 {
616 HeapFree(GetProcessHeap(), 0, buffer);
617 HeapFree(GetProcessHeap(), 0, bin);
618 return ret;
619 }
620
621 TRACE("Helper replied: %s\n", debugstr_a(buffer));
622
623 if( (strncmp(buffer, "KK ", 3) != 0) &&
624 (strncmp(buffer, "AF ", 3) !=0))
625 {
626 TRACE("Helper returned %c%c\n", buffer[0], buffer[1]);
627 HeapFree(GetProcessHeap(), 0, buffer);
628 HeapFree(GetProcessHeap(), 0, bin);
629 return SEC_E_INVALID_TOKEN;
630 }
631
632 /* decode the blob and send it to server */
633 if((ret = decodeBase64(buffer+3, buffer_len-3, bin, max_len,
634 &bin_len)) != SEC_E_OK)
635 {
636 HeapFree(GetProcessHeap(), 0, buffer);
637 HeapFree(GetProcessHeap(), 0, bin);
638 return ret;
639 }
640
641 if(pOutput == NULL)
642 {
643 HeapFree(GetProcessHeap(), 0, buffer);
644 HeapFree(GetProcessHeap(), 0, bin);
645 return SEC_E_INSUFFICIENT_MEMORY;
646 }
647
648 if(pOutput->cBuffers < 1)
649 {
650 HeapFree(GetProcessHeap(), 0, buffer);
651 HeapFree(GetProcessHeap(), 0, bin);
652 return SEC_E_INSUFFICIENT_MEMORY;
653 }
654
655 pOutput->pBuffers[0].cbBuffer = bin_len;
656 pOutput->pBuffers[0].BufferType = SECBUFFER_DATA;
657 memcpy(pOutput->pBuffers[0].pvBuffer, bin, bin_len);
658
659 ret = SEC_E_OK;
660 phNewContext->dwUpper = ctxt_attr;
661 phNewContext->dwLower = ret;
662
663 }
664 HeapFree(GetProcessHeap(), 0, buffer);
665 HeapFree(GetProcessHeap(), 0, bin);
666 if(ret != SEC_I_CONTINUE_NEEDED)
667 {
668 TRACE("Deleting password!\n");
669 if(helper->password)
670 memset(helper->password, 0, helper->pwlen-2);
671 HeapFree(GetProcessHeap(), 0, helper->password);
672 }
673
674 }
675 else
676 {
677 ret = SEC_E_INVALID_HANDLE;
678 TRACE("Helper mode = %d\n", helper->mode);
679 }
680 }
681 else
682 {
683 ret = SEC_E_INVALID_HANDLE;
684 }
685 return ret;
686 }
687
688 /***********************************************************************
689 * InitializeSecurityContextA
690 */
691 static SECURITY_STATUS SEC_ENTRY ntlm_InitializeSecurityContextA(
692 PCredHandle phCredential, PCtxtHandle phContext, SEC_CHAR *pszTargetName,
693 ULONG fContextReq, ULONG Reserved1, ULONG TargetDataRep,
694 PSecBufferDesc pInput,ULONG Reserved2, PCtxtHandle phNewContext,
695 PSecBufferDesc pOutput, ULONG *pfContextAttr, PTimeStamp ptsExpiry)
696 {
697 SECURITY_STATUS ret;
698
699 TRACE("%p %p %s %ld %ld %ld %p %ld %p %p %p %p\n", phCredential, phContext,
700 debugstr_a(pszTargetName), fContextReq, Reserved1, TargetDataRep, pInput,
701 Reserved1, phNewContext, pOutput, pfContextAttr, ptsExpiry);
702
703 if (phCredential)
704 {
705 SEC_WCHAR *target = NULL;
706 if(pszTargetName != NULL)
707 {
708 int target_size = MultiByteToWideChar(CP_ACP, 0, pszTargetName,
709 strlen(pszTargetName)+1, NULL, 0);
710 target = HeapAlloc(GetProcessHeap(), 0, target_size *
711 sizeof(SEC_WCHAR));
712 MultiByteToWideChar(CP_ACP, 0, pszTargetName, strlen(pszTargetName)+1,
713 target, target_size);
714 }
715
716 ret = ntlm_InitializeSecurityContextW(phCredential, phContext, target,
717 fContextReq, Reserved1, TargetDataRep, pInput, Reserved2,
718 phNewContext, pOutput, pfContextAttr, ptsExpiry);
719
720 HeapFree(GetProcessHeap(), 0, target);
721 }
722 else
723 {
724 ret = SEC_E_INVALID_HANDLE;
725 }
726 return ret;
727 }
728
729 /***********************************************************************
730 * AcceptSecurityContext
731 */
732 static SECURITY_STATUS SEC_ENTRY ntlm_AcceptSecurityContext(
733 PCredHandle phCredential, PCtxtHandle phContext, PSecBufferDesc pInput,
734 ULONG fContextReq, ULONG TargetDataRep, PCtxtHandle phNewContext,
735 PSecBufferDesc pOutput, ULONG *pfContextAttr, PTimeStamp ptsExpiry)
736 {
737 SECURITY_STATUS ret;
738
739 TRACE("%p %p %p %ld %ld %p %p %p %p\n", phCredential, phContext, pInput,
740 fContextReq, TargetDataRep, phNewContext, pOutput, pfContextAttr,
741 ptsExpiry);
742 if (phCredential)
743 {
744 PNegoHelper helper = (PNegoHelper)phCredential->dwLower;
745 /* Max size of input data is 2010 byte, as that's the maximum size
746 * ntlm_auth will handle*/
747 char *buffer = HeapAlloc(GetProcessHeap(), 0,
748 sizeof(char) * NTLM_MAX_BUF);
749 PBYTE bin = HeapAlloc(GetProcessHeap(),0, sizeof(BYTE) * NTLM_MAX_BUF);
750 int buffer_len, bin_len, max_len = NTLM_MAX_BUF;
751 ULONG ctxt_attr = 0;
752
753 if(helper->mode != NTLM_SERVER)
754 {
755 HeapFree(GetProcessHeap(), 0, buffer);
756 HeapFree(GetProcessHeap(), 0, bin);
757 return SEC_E_INVALID_HANDLE;
758 }
759
760 /* Handle all the flags */
761 if(fContextReq & ISC_REQ_ALLOCATE_MEMORY)
762 {
763 FIXME("AcceptSecurityContext(): ISC_REQ_ALLOCATE_MEMORY stub\n");
764 }
765 if(fContextReq & ISC_REQ_CONFIDENTIALITY)
766 {
767 FIXME("AcceptSecurityContext(): ISC_REQ_CONFIDENTIALITY stub\n");
768 }
769 if(fContextReq & ISC_REQ_CONNECTION)
770 {
771 /* This is default, so we'll enable it */
772 ctxt_attr |= ISC_RET_CONNECTION;
773 }
774 if(fContextReq & ISC_REQ_EXTENDED_ERROR)
775 {
776 FIXME("AcceptSecurityContext(): ISC_REQ_EXTENDED_ERROR stub\n");
777 }
778 if(fContextReq & ISC_REQ_INTEGRITY)
779 {
780 FIXME("AcceptSecurityContext(): ISC_REQ_INTEGRITY stub\n");
781 }
782 if(fContextReq & ISC_REQ_MUTUAL_AUTH)
783 {
784 FIXME("AcceptSecurityContext(): ISC_REQ_MUTUAL_AUTH stub\n");
785 }
786 if(fContextReq & ISC_REQ_REPLAY_DETECT)
787 {
788 FIXME("AcceptSecurityContext(): ISC_REQ_REPLAY_DETECT stub\n");
789 }
790 if(fContextReq & ISC_REQ_SEQUENCE_DETECT)
791 {
792 FIXME("AcceptSecurityContext(): ISC_REQ_SEQUENCE_DETECT stub\n");
793 }
794 if(fContextReq & ISC_REQ_STREAM)
795 {
796 FIXME("AcceptSecurityContext(): ISC_REQ_STREAM stub\n");
797 }
798 /* Done with the flags */
799 if(TargetDataRep == SECURITY_NETWORK_DREP){
800 FIXME("Don't know how to do SECURITY_NETWORK_DREP\n");
801 HeapFree(GetProcessHeap(), 0, buffer);
802 HeapFree(GetProcessHeap(), 0, bin);
803 return SEC_E_UNSUPPORTED_FUNCTION;
804 }
805
806
807 if(phContext == NULL)
808 {
809 /* This is the first call to AcceptSecurityHandle */
810 if(pInput == NULL)
811 {
812 HeapFree(GetProcessHeap(), 0, buffer);
813 HeapFree(GetProcessHeap(), 0, bin);
814 return SEC_E_INCOMPLETE_MESSAGE;
815 }
816
817 if(pInput->cBuffers < 1)
818 {
819 HeapFree(GetProcessHeap(), 0, buffer);
820 HeapFree(GetProcessHeap(), 0, bin);
821 return SEC_E_INCOMPLETE_MESSAGE;
822 }
823
824 if(pInput->pBuffers[0].cbBuffer > max_len)
825 {
826 HeapFree(GetProcessHeap(), 0, buffer);
827 HeapFree(GetProcessHeap(), 0, bin);
828 return SEC_E_INVALID_TOKEN;
829 }
830 else
831 bin_len = pInput->pBuffers[0].cbBuffer;
832
833 /* This is the YR request from the client, encode to base64 */
834
835 memcpy(bin, pInput->pBuffers[0].pvBuffer, bin_len);
836
837 lstrcpynA(buffer, "YR ", max_len-1);
838
839 if((ret = encodeBase64(bin, bin_len, buffer+3, max_len-3,
840 &buffer_len)) != SEC_E_OK)
841 {
842 HeapFree(GetProcessHeap(), 0, buffer);
843 HeapFree(GetProcessHeap(), 0, bin);
844 return ret;
845 }
846
847 TRACE("Client sent: %s\n", debugstr_a(buffer));
848
849 if((ret = run_helper(helper, buffer, max_len, &buffer_len)) !=
850 SEC_E_OK)
851 {
852 HeapFree(GetProcessHeap(), 0, buffer);
853 HeapFree(GetProcessHeap(), 0, bin);
854 return ret;
855 }
856
857 TRACE("Reply from ntlm_auth: %s\n", debugstr_a(buffer));
858 /* The expected answer is TT <base64 blob> */
859
860 if(strncmp(buffer, "TT ", 3) != 0)
861 {
862 HeapFree(GetProcessHeap(), 0, buffer);
863 HeapFree(GetProcessHeap(), 0, bin);
864 return SEC_E_INVALID_TOKEN;
865 }
866
867 if((ret = decodeBase64(buffer+3, buffer_len-3, bin, max_len,
868 &bin_len)) != SEC_E_OK)
869 {
870 HeapFree(GetProcessHeap(), 0, buffer);
871 HeapFree(GetProcessHeap(), 0, bin);
872 return ret;
873 }
874
875 /* send this to the client */
876 if(pOutput == NULL)
877 {
878 HeapFree(GetProcessHeap(), 0, buffer);
879 HeapFree(GetProcessHeap(), 0, bin);
880 return SEC_E_INSUFFICIENT_MEMORY;
881 }
882
883 if(pOutput->cBuffers < 1)
884 {
885 HeapFree(GetProcessHeap(), 0, buffer);
886 HeapFree(GetProcessHeap(), 0, bin);
887 return SEC_E_INSUFFICIENT_MEMORY;
888 }
889
890 pOutput->pBuffers[0].cbBuffer = bin_len;
891 pOutput->pBuffers[0].BufferType = SECBUFFER_DATA;
892 memcpy(pOutput->pBuffers[0].pvBuffer, bin, bin_len);
893 ret = SEC_I_CONTINUE_NEEDED;
894
895 }
896 else
897 {
898 /* we expect a KK request from client */
899 if(pInput == NULL)
900 {
901 HeapFree(GetProcessHeap(), 0, buffer);
902 HeapFree(GetProcessHeap(), 0, bin);
903 return SEC_E_INCOMPLETE_MESSAGE;
904 }
905
906 if(pInput->cBuffers < 1)
907 {
908 HeapFree(GetProcessHeap(), 0, buffer);
909 HeapFree(GetProcessHeap(), 0, bin);
910 return SEC_E_INCOMPLETE_MESSAGE;
911 }
912
913 if(pInput->pBuffers[0].cbBuffer > max_len)
914 {
915 HeapFree(GetProcessHeap(), 0, buffer);
916 HeapFree(GetProcessHeap(), 0, bin);
917 return SEC_E_INVALID_TOKEN;
918 }
919 else
920 bin_len = pInput->pBuffers[0].cbBuffer;
921
922 memcpy(bin, pInput->pBuffers[0].pvBuffer, bin_len);
923
924 lstrcpynA(buffer, "KK ", max_len-1);
925
926 if((ret = encodeBase64(bin, bin_len, buffer+3, max_len-3,
927 &buffer_len)) != SEC_E_OK)
928 {
929 HeapFree(GetProcessHeap(), 0, buffer);
930 HeapFree(GetProcessHeap(), 0, bin);
931 return ret;
932 }
933
934 TRACE("Client sent: %s\n", debugstr_a(buffer));
935
936 if((ret = run_helper(helper, buffer, max_len, &buffer_len)) !=
937 SEC_E_OK)
938 {
939 HeapFree(GetProcessHeap(), 0, buffer);
940 HeapFree(GetProcessHeap(), 0, bin);
941 return ret;
942 }
943
944 TRACE("Reply from ntlm_auth: %s\n", debugstr_a(buffer));
945
946 if(strncmp(buffer, "AF ", 3) != 0)
947 {
948 if(strncmp(buffer, "NA ", 3) == 0)
949 {
950 HeapFree(GetProcessHeap(), 0, buffer);
951 HeapFree(GetProcessHeap(), 0, bin);
952 return SEC_E_LOGON_DENIED;
953 }
954 else
955 {
956 HeapFree(GetProcessHeap(), 0, buffer);
957 HeapFree(GetProcessHeap(), 0, bin);
958 return SEC_E_INVALID_TOKEN;
959 }
960 }
961
962 ret = SEC_E_OK;
963 }
964
965 phNewContext->dwUpper = ctxt_attr;
966 phNewContext->dwLower = ret;
967 HeapFree(GetProcessHeap(), 0, buffer);
968 HeapFree(GetProcessHeap(), 0, bin);
969
970 }
971 else
972 {
973 ret = SEC_E_INVALID_HANDLE;
974 }
975 return ret;
976 }
977
978 /***********************************************************************
979 * CompleteAuthToken
980 */
981 static SECURITY_STATUS SEC_ENTRY ntlm_CompleteAuthToken(PCtxtHandle phContext,
982 PSecBufferDesc pToken)
983 {
984 SECURITY_STATUS ret;
985
986 TRACE("%p %p\n", phContext, pToken);
987 if (phContext)
988 {
989 ret = SEC_E_UNSUPPORTED_FUNCTION;
990 }
991 else
992 {
993 ret = SEC_E_INVALID_HANDLE;
994 }
995 return ret;
996 }
997
998 /***********************************************************************
999 * DeleteSecurityContext
1000 */
1001 static SECURITY_STATUS SEC_ENTRY ntlm_DeleteSecurityContext(PCtxtHandle phContext)
1002 {
1003 SECURITY_STATUS ret;
1004
1005 TRACE("%p\n", phContext);
1006 if (phContext)
1007 {
1008 phContext->dwUpper = 0;
1009 phContext->dwLower = 0;
1010 ret = SEC_E_OK;
1011 }
1012 else
1013 {
1014 ret = SEC_E_INVALID_HANDLE;
1015 }
1016 return ret;
1017 }
1018
1019 /***********************************************************************
1020 * QueryContextAttributesW
1021 */
1022 static SECURITY_STATUS SEC_ENTRY ntlm_QueryContextAttributesW(PCtxtHandle phContext,
1023 unsigned long ulAttribute, void *pBuffer)
1024 {
1025 SECURITY_STATUS ret;
1026
1027 /* FIXME: From reading wrapper.h, I think the dwUpper part of a context is
1028 * the SecurePackage part and the dwLower part is the actual context
1029 * handle. It should be easy to extract the context attributes from that.
1030 */
1031 TRACE("%p %ld %p\n", phContext, ulAttribute, pBuffer);
1032 if (phContext)
1033 {
1034 ret = SEC_E_UNSUPPORTED_FUNCTION;
1035 }
1036 else
1037 {
1038 ret = SEC_E_INVALID_HANDLE;
1039 }
1040 return ret;
1041 }
1042
1043 /***********************************************************************
1044 * QueryContextAttributesA
1045 */
1046 static SECURITY_STATUS SEC_ENTRY ntlm_QueryContextAttributesA(PCtxtHandle phContext,
1047 unsigned long ulAttribute, void *pBuffer)
1048 {
1049 return ntlm_QueryContextAttributesW(phContext, ulAttribute, pBuffer);
1050 }
1051
1052 /***********************************************************************
1053 * ImpersonateSecurityContext
1054 */
1055 static SECURITY_STATUS SEC_ENTRY ntlm_ImpersonateSecurityContext(PCtxtHandle phContext)
1056 {
1057 SECURITY_STATUS ret;
1058
1059 TRACE("%p\n", phContext);
1060 if (phContext)
1061 {
1062 ret = SEC_E_UNSUPPORTED_FUNCTION;
1063 }
1064 else
1065 {
1066 ret = SEC_E_INVALID_HANDLE;
1067 }
1068 return ret;
1069 }
1070
1071 /***********************************************************************
1072 * RevertSecurityContext
1073 */
1074 static SECURITY_STATUS SEC_ENTRY ntlm_RevertSecurityContext(PCtxtHandle phContext)
1075 {
1076 SECURITY_STATUS ret;
1077
1078 TRACE("%p\n", phContext);
1079 if (phContext)
1080 {
1081 ret = SEC_E_UNSUPPORTED_FUNCTION;
1082 }
1083 else
1084 {
1085 ret = SEC_E_INVALID_HANDLE;
1086 }
1087 return ret;
1088 }
1089
1090 /***********************************************************************
1091 * MakeSignature
1092 */
1093 static SECURITY_STATUS SEC_ENTRY ntlm_MakeSignature(PCtxtHandle phContext, ULONG fQOP,
1094 PSecBufferDesc pMessage, ULONG MessageSeqNo)
1095 {
1096 SECURITY_STATUS ret;
1097
1098 TRACE("%p %ld %p %ld\n", phContext, fQOP, pMessage, MessageSeqNo);
1099 if (phContext)
1100 {
1101 ret = SEC_E_UNSUPPORTED_FUNCTION;
1102 }
1103 else
1104 {
1105 ret = SEC_E_INVALID_HANDLE;
1106 }
1107 return ret;
1108 }
1109
1110 /***********************************************************************
1111 * VerifySignature
1112 */
1113 static SECURITY_STATUS SEC_ENTRY ntlm_VerifySignature(PCtxtHandle phContext,
1114 PSecBufferDesc pMessage, ULONG MessageSeqNo, PULONG pfQOP)
1115 {
1116 SECURITY_STATUS ret;
1117
1118 TRACE("%p %p %ld %p\n", phContext, pMessage, MessageSeqNo, pfQOP);
1119 if (phContext)
1120 {
1121 ret = SEC_E_UNSUPPORTED_FUNCTION;
1122 }
1123 else
1124 {
1125 ret = SEC_E_INVALID_HANDLE;
1126 }
1127 return ret;
1128 }
1129
1130 /***********************************************************************
1131 * FreeCredentialsHandle
1132 */
1133 static SECURITY_STATUS SEC_ENTRY ntlm_FreeCredentialsHandle(
1134 PCredHandle phCredential)
1135 {
1136 SECURITY_STATUS ret;
1137
1138 if(phCredential){
1139 PNegoHelper helper = (PNegoHelper) phCredential->dwLower;
1140 phCredential->dwUpper = 0;
1141 phCredential->dwLower = 0;
1142 cleanup_helper(helper);
1143 ret = SEC_E_OK;
1144 }
1145 else
1146 ret = SEC_E_OK;
1147
1148 return ret;
1149 }
1150
1151 static SecurityFunctionTableA ntlmTableA = {
1152 1,
1153 NULL, /* EnumerateSecurityPackagesA */
1154 ntlm_QueryCredentialsAttributesA, /* QueryCredentialsAttributesA */
1155 ntlm_AcquireCredentialsHandleA, /* AcquireCredentialsHandleA */
1156 ntlm_FreeCredentialsHandle, /* FreeCredentialsHandle */
1157 NULL, /* Reserved2 */
1158 ntlm_InitializeSecurityContextA, /* InitializeSecurityContextA */
1159 ntlm_AcceptSecurityContext, /* AcceptSecurityContext */
1160 ntlm_CompleteAuthToken, /* CompleteAuthToken */
1161 ntlm_DeleteSecurityContext, /* DeleteSecurityContext */
1162 NULL, /* ApplyControlToken */
1163 ntlm_QueryContextAttributesA, /* QueryContextAttributesA */
1164 ntlm_ImpersonateSecurityContext, /* ImpersonateSecurityContext */
1165 ntlm_RevertSecurityContext, /* RevertSecurityContext */
1166 ntlm_MakeSignature, /* MakeSignature */
1167 ntlm_VerifySignature, /* VerifySignature */
1168 FreeContextBuffer, /* FreeContextBuffer */
1169 NULL, /* QuerySecurityPackageInfoA */
1170 NULL, /* Reserved3 */
1171 NULL, /* Reserved4 */
1172 NULL, /* ExportSecurityContext */
1173 NULL, /* ImportSecurityContextA */
1174 NULL, /* AddCredentialsA */
1175 NULL, /* Reserved8 */
1176 NULL, /* QuerySecurityContextToken */
1177 NULL, /* EncryptMessage */
1178 NULL, /* DecryptMessage */
1179 NULL, /* SetContextAttributesA */
1180 };
1181
1182 static SecurityFunctionTableW ntlmTableW = {
1183 1,
1184 NULL, /* EnumerateSecurityPackagesW */
1185 ntlm_QueryCredentialsAttributesW, /* QueryCredentialsAttributesW */
1186 ntlm_AcquireCredentialsHandleW, /* AcquireCredentialsHandleW */
1187 ntlm_FreeCredentialsHandle, /* FreeCredentialsHandle */
1188 NULL, /* Reserved2 */
1189 ntlm_InitializeSecurityContextW, /* InitializeSecurityContextW */
1190 ntlm_AcceptSecurityContext, /* AcceptSecurityContext */
1191 ntlm_CompleteAuthToken, /* CompleteAuthToken */
1192 ntlm_DeleteSecurityContext, /* DeleteSecurityContext */
1193 NULL, /* ApplyControlToken */
1194 ntlm_QueryContextAttributesW, /* QueryContextAttributesW */
1195 ntlm_ImpersonateSecurityContext, /* ImpersonateSecurityContext */
1196 ntlm_RevertSecurityContext, /* RevertSecurityContext */
1197 ntlm_MakeSignature, /* MakeSignature */
1198 ntlm_VerifySignature, /* VerifySignature */
1199 FreeContextBuffer, /* FreeContextBuffer */
1200 NULL, /* QuerySecurityPackageInfoW */
1201 NULL, /* Reserved3 */
1202 NULL, /* Reserved4 */
1203 NULL, /* ExportSecurityContext */
1204 NULL, /* ImportSecurityContextW */
1205 NULL, /* AddCredentialsW */
1206 NULL, /* Reserved8 */
1207 NULL, /* QuerySecurityContextToken */
1208 NULL, /* EncryptMessage */
1209 NULL, /* DecryptMessage */
1210 NULL, /* SetContextAttributesW */
1211 };
1212
1213 static WCHAR ntlm_comment_W[] = { 'N', 'T', 'L', 'M', ' ', 'S', 'e',
1214 'c', 'u', 'r', 'i', 't', 'y', ' ', 'P', 'a', 'c', 'k', 'a', 'g', 'e',0};
1215
1216 static CHAR ntlm_comment_A[] = "NTLM Security Package";
1217
1218 void SECUR32_initNTLMSP(void)
1219 {
1220 SECURITY_STATUS ret;
1221 PNegoHelper helper;
1222
1223 SEC_CHAR *args[] = {
1224 "ntlm_auth",
1225 "--version",
1226 NULL };
1227
1228 if((ret = fork_helper(&helper, "ntlm_auth", args)) != SEC_E_OK)
1229 {
1230 /* Cheat and allocate a helper anyway, so cleanup later will work. */
1231 helper = HeapAlloc(GetProcessHeap,0, sizeof(PNegoHelper));
1232 helper->version = -1;
1233 }
1234 else
1235 {
1236 check_version(helper);
1237 }
1238
1239 if(helper->version > 2)
1240 {
1241
1242 SecureProvider *provider = SECUR32_addProvider(&ntlmTableA, &ntlmTableW,
1243 NULL);
1244 /* According to Windows, NTLM has the following capabilities.
1245 */
1246
1247 static const LONG caps =
1248 SECPKG_FLAG_INTEGRITY |
1249 SECPKG_FLAG_PRIVACY |
1250 SECPKG_FLAG_TOKEN_ONLY |
1251 SECPKG_FLAG_CONNECTION |
1252 SECPKG_FLAG_MULTI_REQUIRED |
1253 SECPKG_FLAG_IMPERSONATION |
1254 SECPKG_FLAG_ACCEPT_WIN32_NAME |
1255 SECPKG_FLAG_READONLY_WITH_CHECKSUM;
1256
1257 static const USHORT version = 1;
1258 static const USHORT rpcid = 10;
1259 /* In Windows, this is 12000, but ntlm_auth won't take more than 2010
1260 * characters, so there is no use reporting a bigger size */
1261 static const ULONG max_token = NTLM_MAX_BUF;
1262 const SecPkgInfoW infoW = { caps, version, rpcid, max_token, ntlm_name_W,
1263 ntlm_comment_W};
1264 const SecPkgInfoA infoA = { caps, version, rpcid, max_token, ntlm_name_A,
1265 ntlm_comment_A};
1266
1267 SECUR32_addPackages(provider, 1L, &infoA, &infoW);
1268 }
1269 cleanup_helper(helper);
1270
1271 }
Windows API implementation