git.oblomov.eu Git - wine/blob - dlls/secur32/ntlm.c

   1 /*
   2  * Copyright 2005, 2006 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  *
  18  * This file implements the NTLM security provider.
  19  */
  20
  21 #include <assert.h>
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winnls.h"
  27 #include "wincred.h"
  28 #include "rpc.h"
  29 #include "sspi.h"
  30 #include "lm.h"
  31 #include "secur32_priv.h"
  32 #include "hmac_md5.h"
  33 #include "wine/unicode.h"
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(ntlm);
  37
  38 #define NTLM_MAX_BUF 1904
  39 #define MIN_NTLM_AUTH_MAJOR_VERSION 3
  40 #define MIN_NTLM_AUTH_MINOR_VERSION 0
  41 #define MIN_NTLM_AUTH_MICRO_VERSION 25
  42
  43 static CHAR ntlm_auth[] = "ntlm_auth";
  44
  45 typedef struct _NtlmCredentials
  46 {
  47     HelperMode mode;
  48
  49     /* these are all in the Unix codepage */
  50     char *username_arg;
  51     char *domain_arg;
  52     char *password; /* not nul-terminated */
  53     int pwlen;
  54 } NtlmCredentials, *PNtlmCredentials;
  55
  56 /***********************************************************************
  57  *              QueryCredentialsAttributesA
  58  */
  59 static SECURITY_STATUS SEC_ENTRY ntlm_QueryCredentialsAttributesA(
  60         PCredHandle phCredential, ULONG ulAttribute, PVOID pBuffer)
  61 {
  62     SECURITY_STATUS ret;
  63
  64     TRACE("(%p, %d, %p)\n", phCredential, ulAttribute, pBuffer);
  65
  66     if(ulAttribute == SECPKG_ATTR_NAMES)
  67     {
  68         FIXME("SECPKG_CRED_ATTR_NAMES: stub\n");
  69         ret = SEC_E_UNSUPPORTED_FUNCTION;
  70     }
  71     else
  72         ret = SEC_E_UNSUPPORTED_FUNCTION;
  73
  74     return ret;
  75 }
  76
  77 /***********************************************************************
  78  *              QueryCredentialsAttributesW
  79  */
  80 static SECURITY_STATUS SEC_ENTRY ntlm_QueryCredentialsAttributesW(
  81         PCredHandle phCredential, ULONG ulAttribute, PVOID pBuffer)
  82 {
  83     SECURITY_STATUS ret;
  84
  85     TRACE("(%p, %d, %p)\n", phCredential, ulAttribute, pBuffer);
  86
  87     if(ulAttribute == SECPKG_ATTR_NAMES)
  88     {
  89         FIXME("SECPKG_CRED_ATTR_NAMES: stub\n");
  90         ret = SEC_E_UNSUPPORTED_FUNCTION;
  91     }
  92     else
  93         ret = SEC_E_UNSUPPORTED_FUNCTION;
  94
  95     return ret;
  96 }
  97
  98 static char *ntlm_GetUsernameArg(LPCWSTR userW, INT userW_length)
  99 {
 100     static const char username_arg[] = "--username=";
 101     char *user;
 102     int unixcp_size;
 103
 104     unixcp_size =  WideCharToMultiByte(CP_UNIXCP, WC_NO_BEST_FIT_CHARS,
 105         userW, userW_length, NULL, 0, NULL, NULL) + sizeof(username_arg);
 106     user = HeapAlloc(GetProcessHeap(), 0, unixcp_size);
 107     if (!user) return NULL;
 108     memcpy(user, username_arg, sizeof(username_arg) - 1);
 109     WideCharToMultiByte(CP_UNIXCP, WC_NO_BEST_FIT_CHARS, userW, userW_length,
 110         user + sizeof(username_arg) - 1,
 111         unixcp_size - sizeof(username_arg) + 1, NULL, NULL);
 112     user[unixcp_size - 1] = '\0';
 113     return user;
 114 }
 115
 116 static char *ntlm_GetDomainArg(LPCWSTR domainW, INT domainW_length)
 117 {
 118     static const char domain_arg[] = "--domain=";
 119     char *domain;
 120     int unixcp_size;
 121
 122     unixcp_size = WideCharToMultiByte(CP_UNIXCP, WC_NO_BEST_FIT_CHARS,
 123         domainW, domainW_length, NULL, 0,  NULL, NULL) + sizeof(domain_arg);
 124     domain = HeapAlloc(GetProcessHeap(), 0, unixcp_size);
 125     if (!domain) return NULL;
 126     memcpy(domain, domain_arg, sizeof(domain_arg) - 1);
 127     WideCharToMultiByte(CP_UNIXCP, WC_NO_BEST_FIT_CHARS, domainW,
 128         domainW_length, domain + sizeof(domain_arg) - 1,
 129         unixcp_size - sizeof(domain) + 1, NULL, NULL);
 130     domain[unixcp_size - 1] = '\0';
 131     return domain;
 132 }
 133
 134 /***********************************************************************
 135  *              AcquireCredentialsHandleW
 136  */
 137 static SECURITY_STATUS SEC_ENTRY ntlm_AcquireCredentialsHandleW(
 138  SEC_WCHAR *pszPrincipal, SEC_WCHAR *pszPackage, ULONG fCredentialUse,
 139  PLUID pLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn,
 140  PVOID pGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry)
 141 {
 142     SECURITY_STATUS ret;
 143     PNtlmCredentials ntlm_cred = NULL;
 144     SEC_WCHAR *username = NULL, *domain = NULL;
 145
 146     TRACE("(%s, %s, 0x%08x, %p, %p, %p, %p, %p, %p)\n",
 147      debugstr_w(pszPrincipal), debugstr_w(pszPackage), fCredentialUse,
 148      pLogonID, pAuthData, pGetKeyFn, pGetKeyArgument, phCredential, ptsExpiry);
 149
 150     switch(fCredentialUse)
 151     {
 152         case SECPKG_CRED_INBOUND:
 153             ntlm_cred = HeapAlloc(GetProcessHeap(), 0, sizeof(*ntlm_cred));
 154             if (!ntlm_cred)
 155                 ret = SEC_E_INSUFFICIENT_MEMORY;
 156             else
 157             {
 158                 ntlm_cred->mode = NTLM_SERVER;
 159                 ntlm_cred->username_arg = NULL;
 160                 ntlm_cred->domain_arg = NULL;
 161                 ntlm_cred->password = NULL;
 162                 ntlm_cred->pwlen = 0;
 163                 phCredential->dwUpper = fCredentialUse;
 164                 phCredential->dwLower = (ULONG_PTR)ntlm_cred;
 165                 ret = SEC_E_OK;
 166             }
 167             break;
 168         case SECPKG_CRED_OUTBOUND:
 169             {
 170                 ntlm_cred = HeapAlloc(GetProcessHeap(), 0, sizeof(*ntlm_cred));
 171                 if (!ntlm_cred)
 172                 {
 173                     ret = SEC_E_INSUFFICIENT_MEMORY;
 174                     break;
 175                 }
 176                 ntlm_cred->mode = NTLM_CLIENT;
 177                 ntlm_cred->username_arg = NULL;
 178                 ntlm_cred->domain_arg = NULL;
 179                 ntlm_cred->password = NULL;
 180                 ntlm_cred->pwlen = 0;
 181
 182                 if(pAuthData != NULL)
 183                 {
 184                     PSEC_WINNT_AUTH_IDENTITY_W auth_data = pAuthData;
 185
 186                     TRACE("Username is %s\n", debugstr_wn(auth_data->User, auth_data->UserLength));
 187                     TRACE("Domain name is %s\n", debugstr_wn(auth_data->Domain, auth_data->DomainLength));
 188
 189                     ntlm_cred->username_arg = ntlm_GetUsernameArg(auth_data->User, auth_data->UserLength);
 190                     ntlm_cred->domain_arg = ntlm_GetDomainArg(auth_data->Domain, auth_data->DomainLength);
 191
 192                     if(auth_data->PasswordLength != 0)
 193                     {
 194                         ntlm_cred->pwlen = WideCharToMultiByte(CP_UNIXCP,
 195                                                                WC_NO_BEST_FIT_CHARS, auth_data->Password,
 196                                                                auth_data->PasswordLength, NULL, 0, NULL,
 197                                                                NULL);
 198
 199                         ntlm_cred->password = HeapAlloc(GetProcessHeap(), 0,
 200                                                         ntlm_cred->pwlen);
 201
 202                         WideCharToMultiByte(CP_UNIXCP, WC_NO_BEST_FIT_CHARS,
 203                                             auth_data->Password, auth_data->PasswordLength,
 204                                             ntlm_cred->password, ntlm_cred->pwlen, NULL, NULL);
 205                     }
 206                 }
 207
 208                 phCredential->dwUpper = fCredentialUse;
 209                 phCredential->dwLower = (ULONG_PTR)ntlm_cred;
 210                 TRACE("ACH phCredential->dwUpper: 0x%08lx, dwLower: 0x%08lx\n",
 211                       phCredential->dwUpper, phCredential->dwLower);
 212                 ret = SEC_E_OK;
 213                 break;
 214             }
 215         case SECPKG_CRED_BOTH:
 216             FIXME("AcquireCredentialsHandle: SECPKG_CRED_BOTH stub\n");
 217             ret = SEC_E_UNSUPPORTED_FUNCTION;
 218             phCredential = NULL;
 219             break;
 220         default:
 221             phCredential = NULL;
 222             ret = SEC_E_UNKNOWN_CREDENTIALS;
 223     }
 224
 225     HeapFree(GetProcessHeap(), 0, username);
 226     HeapFree(GetProcessHeap(), 0, domain);
 227
 228     return ret;
 229 }
 230
 231 /***********************************************************************
 232  *              AcquireCredentialsHandleA
 233  */
 234 static SECURITY_STATUS SEC_ENTRY ntlm_AcquireCredentialsHandleA(
 235  SEC_CHAR *pszPrincipal, SEC_CHAR *pszPackage, ULONG fCredentialUse,
 236  PLUID pLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn,
 237  PVOID pGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry)
 238 {
 239     SECURITY_STATUS ret;
 240     int user_sizeW, domain_sizeW, passwd_sizeW;
 241
 242     SEC_WCHAR *user = NULL, *domain = NULL, *passwd = NULL, *package = NULL;
 243
 244     PSEC_WINNT_AUTH_IDENTITY_W pAuthDataW = NULL;
 245     PSEC_WINNT_AUTH_IDENTITY_A identity  = NULL;
 246
 247     TRACE("(%s, %s, 0x%08x, %p, %p, %p, %p, %p, %p)\n",
 248      debugstr_a(pszPrincipal), debugstr_a(pszPackage), fCredentialUse,
 249      pLogonID, pAuthData, pGetKeyFn, pGetKeyArgument, phCredential, ptsExpiry);
 250
 251     if(pszPackage != NULL)
 252     {
 253         int package_sizeW = MultiByteToWideChar(CP_ACP, 0, pszPackage, -1,
 254                 NULL, 0);
 255
 256         package = HeapAlloc(GetProcessHeap(), 0, package_sizeW *
 257                 sizeof(SEC_WCHAR));
 258         MultiByteToWideChar(CP_ACP, 0, pszPackage, -1, package, package_sizeW);
 259     }
 260
 261
 262     if(pAuthData != NULL)
 263     {
 264         identity = pAuthData;
 265
 266         if(identity->Flags == SEC_WINNT_AUTH_IDENTITY_ANSI)
 267         {
 268             pAuthDataW = HeapAlloc(GetProcessHeap(), 0,
 269                     sizeof(SEC_WINNT_AUTH_IDENTITY_W));
 270
 271             if(identity->UserLength != 0)
 272             {
 273                 user_sizeW = MultiByteToWideChar(CP_ACP, 0,
 274                     (LPCSTR)identity->User, identity->UserLength, NULL, 0);
 275                 user = HeapAlloc(GetProcessHeap(), 0, user_sizeW *
 276                         sizeof(SEC_WCHAR));
 277                 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)identity->User,
 278                     identity->UserLength, user, user_sizeW);
 279             }
 280             else
 281             {
 282                 user_sizeW = 0;
 283             }
 284
 285             if(identity->DomainLength != 0)
 286             {
 287                 domain_sizeW = MultiByteToWideChar(CP_ACP, 0,
 288                     (LPCSTR)identity->Domain, identity->DomainLength, NULL, 0);
 289                 domain = HeapAlloc(GetProcessHeap(), 0, domain_sizeW
 290                     * sizeof(SEC_WCHAR));
 291                 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)identity->Domain,
 292                     identity->DomainLength, domain, domain_sizeW);
 293             }
 294             else
 295             {
 296                 domain_sizeW = 0;
 297             }
 298
 299             if(identity->PasswordLength != 0)
 300             {
 301                 passwd_sizeW = MultiByteToWideChar(CP_ACP, 0,
 302                     (LPCSTR)identity->Password, identity->PasswordLength,
 303                     NULL, 0);
 304                 passwd = HeapAlloc(GetProcessHeap(), 0, passwd_sizeW
 305                     * sizeof(SEC_WCHAR));
 306                 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)identity->Password,
 307                     identity->PasswordLength, passwd, passwd_sizeW);
 308             }
 309             else
 310             {
 311                 passwd_sizeW = 0;
 312             }
 313
 314             pAuthDataW->Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
 315             pAuthDataW->User = user;
 316             pAuthDataW->UserLength = user_sizeW;
 317             pAuthDataW->Domain = domain;
 318             pAuthDataW->DomainLength = domain_sizeW;
 319             pAuthDataW->Password = passwd;
 320             pAuthDataW->PasswordLength = passwd_sizeW;
 321         }
 322         else
 323         {
 324             pAuthDataW = (PSEC_WINNT_AUTH_IDENTITY_W)identity;
 325         }
 326     }
 327
 328     ret = ntlm_AcquireCredentialsHandleW(NULL, package, fCredentialUse,
 329             pLogonID, pAuthDataW, pGetKeyFn, pGetKeyArgument, phCredential,
 330             ptsExpiry);
 331
 332     HeapFree(GetProcessHeap(), 0, package);
 333     HeapFree(GetProcessHeap(), 0, user);
 334     HeapFree(GetProcessHeap(), 0, domain);
 335     HeapFree(GetProcessHeap(), 0, passwd);
 336     if(pAuthDataW != (PSEC_WINNT_AUTH_IDENTITY_W)identity)
 337         HeapFree(GetProcessHeap(), 0, pAuthDataW);
 338
 339     return ret;
 340 }
 341
 342 /*************************************************************************
 343  *             ntlm_GetTokenBufferIndex
 344  * Calculates the index of the secbuffer with BufferType == SECBUFFER_TOKEN
 345  * Returns index if found or -1 if not found.
 346  */
 347 static int ntlm_GetTokenBufferIndex(PSecBufferDesc pMessage)
 348 {
 349     UINT i;
 350
 351     TRACE("%p\n", pMessage);
 352
 353     for( i = 0; i < pMessage->cBuffers; ++i )
 354     {
 355         if(pMessage->pBuffers[i].BufferType == SECBUFFER_TOKEN)
 356             return i;
 357     }
 358
 359     return -1;
 360 }
 361
 362 /*************************************************************************
 363  *             ntlm_GetDataBufferIndex
 364  * Calculates the index of the first secbuffer with BufferType == SECBUFFER_DATA
 365  * Returns index if found or -1 if not found.
 366  */
 367 static int ntlm_GetDataBufferIndex(PSecBufferDesc pMessage)
 368 {
 369     UINT i;
 370
 371     TRACE("%p\n", pMessage);
 372
 373     for( i = 0; i < pMessage->cBuffers; ++i )
 374     {
 375         if(pMessage->pBuffers[i].BufferType == SECBUFFER_DATA)
 376             return i;
 377     }
 378
 379     return -1;
 380 }
 381
 382 static BOOL ntlm_GetCachedCredential(const SEC_WCHAR *pszTargetName, PCREDENTIALW *cred)
 383 {
 384     LPCWSTR p;
 385     LPCWSTR pszHost;
 386     LPWSTR pszHostOnly;
 387     BOOL ret;
 388
 389     if (!pszTargetName)
 390         return FALSE;
 391
 392     /* try to get the start of the hostname from service principal name (SPN) */
 393     pszHost = strchrW(pszTargetName, '/');
 394     if (pszHost)
 395     {
 396         /* skip slash character */
 397         pszHost++;
 398
 399         /* find end of host by detecting start of instance port or start of referrer */
 400         p = strchrW(pszHost, ':');
 401         if (!p)
 402             p = strchrW(pszHost, '/');
 403         if (!p)
 404             p = pszHost + strlenW(pszHost);
 405     }
 406     else /* otherwise not an SPN, just a host */
 407     {
 408         pszHost = pszTargetName;
 409         p = pszHost + strlenW(pszHost);
 410     }
 411
 412     pszHostOnly = HeapAlloc(GetProcessHeap(), 0, (p - pszHost + 1) * sizeof(WCHAR));
 413     if (!pszHostOnly)
 414         return FALSE;
 415
 416     memcpy(pszHostOnly, pszHost, (p - pszHost) * sizeof(WCHAR));
 417     pszHostOnly[p - pszHost] = '\0';
 418
 419     ret = CredReadW(pszHostOnly, CRED_TYPE_DOMAIN_PASSWORD, 0, cred);
 420
 421     HeapFree(GetProcessHeap(), 0, pszHostOnly);
 422     return ret;
 423 }
 424
 425 /***********************************************************************
 426  *              InitializeSecurityContextW
 427  */
 428 static SECURITY_STATUS SEC_ENTRY ntlm_InitializeSecurityContextW(
 429  PCredHandle phCredential, PCtxtHandle phContext, SEC_WCHAR *pszTargetName,
 430  ULONG fContextReq, ULONG Reserved1, ULONG TargetDataRep,
 431  PSecBufferDesc pInput, ULONG Reserved2, PCtxtHandle phNewContext,
 432  PSecBufferDesc pOutput, ULONG *pfContextAttr, PTimeStamp ptsExpiry)
 433 {
 434     SECURITY_STATUS ret;
 435     PNtlmCredentials ntlm_cred = NULL;
 436     PNegoHelper helper = NULL;
 437     ULONG ctxt_attr = 0;
 438     char* buffer, *want_flags = NULL;
 439     PBYTE bin;
 440     int buffer_len, bin_len, max_len = NTLM_MAX_BUF;
 441     int token_idx;
 442     SEC_CHAR *username = NULL;
 443     SEC_CHAR *domain = NULL;
 444     SEC_CHAR *password = NULL;
 445
 446     TRACE("%p %p %s %d %d %d %p %d %p %p %p %p\n", phCredential, phContext,
 447      debugstr_w(pszTargetName), fContextReq, Reserved1, TargetDataRep, pInput,
 448      Reserved1, phNewContext, pOutput, pfContextAttr, ptsExpiry);
 449
 450     /****************************************
 451      * When communicating with the client, there can be the
 452      * following reply packets:
 453      * YR <base64 blob>         should be sent to the server
 454      * PW                       should be sent back to helper with
 455      *                          base64 encoded password
 456      * AF <base64 blob>         client is done, blob should be
 457      *                          sent to server with KK prefixed
 458      * GF <string list>         A string list of negotiated flags
 459      * GK <base64 blob>         base64 encoded session key
 460      * BH <char reason>         something broke
 461      */
 462     /* The squid cache size is 2010 chars, and that's what ntlm_auth uses */
 463
 464     if(TargetDataRep == SECURITY_NETWORK_DREP){
 465         TRACE("Setting SECURITY_NETWORK_DREP\n");
 466     }
 467
 468     buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(char) * NTLM_MAX_BUF);
 469     bin = HeapAlloc(GetProcessHeap(), 0, sizeof(BYTE) * NTLM_MAX_BUF);
 470
 471     if((phContext == NULL) && (pInput == NULL))
 472     {
 473         static char helper_protocol[] = "--helper-protocol=ntlmssp-client-1";
 474         SEC_CHAR *client_argv[5];
 475         int pwlen = 0;
 476
 477         TRACE("First time in ISC()\n");
 478
 479         if(!phCredential)
 480         {
 481             ret = SEC_E_INVALID_HANDLE;
 482             goto isc_end;
 483         }
 484
 485         /* As the server side of sspi never calls this, make sure that
 486          * the handler is a client handler.
 487          */
 488         ntlm_cred = (PNtlmCredentials)phCredential->dwLower;
 489         if(ntlm_cred->mode != NTLM_CLIENT)
 490         {
 491             TRACE("Cred mode = %d\n", ntlm_cred->mode);
 492             ret = SEC_E_INVALID_HANDLE;
 493             goto isc_end;
 494         }
 495
 496         client_argv[0] = ntlm_auth;
 497         client_argv[1] = helper_protocol;
 498         if (!ntlm_cred->username_arg && !ntlm_cred->domain_arg)
 499         {
 500             LPWKSTA_USER_INFO_1 ui = NULL;
 501             NET_API_STATUS status;
 502             PCREDENTIALW cred;
 503
 504             if (ntlm_GetCachedCredential(pszTargetName, &cred))
 505             {
 506                 LPWSTR p;
 507                 p = strchrW(cred->UserName, '\\');
 508                 if (p)
 509                 {
 510                     domain = ntlm_GetDomainArg(cred->UserName, p - cred->UserName);
 511                     p++;
 512                 }
 513                 else
 514                 {
 515                     domain = ntlm_GetDomainArg(NULL, 0);
 516                     p = cred->UserName;
 517                 }
 518
 519                 username = ntlm_GetUsernameArg(p, -1);
 520
 521                 if(cred->CredentialBlobSize != 0)
 522                 {
 523                     pwlen = WideCharToMultiByte(CP_UNIXCP,
 524                         WC_NO_BEST_FIT_CHARS, (LPWSTR)cred->CredentialBlob,
 525                         cred->CredentialBlobSize / sizeof(WCHAR), NULL, 0,
 526                         NULL, NULL);
 527
 528                     password = HeapAlloc(GetProcessHeap(), 0, pwlen);
 529
 530                     WideCharToMultiByte(CP_UNIXCP, WC_NO_BEST_FIT_CHARS,
 531                                         (LPWSTR)cred->CredentialBlob,
 532                                         cred->CredentialBlobSize / sizeof(WCHAR),
 533                                         password, pwlen, NULL, NULL);
 534                 }
 535
 536                 CredFree(cred);
 537
 538                 client_argv[2] = username;
 539                 client_argv[3] = domain;
 540                 client_argv[4] = NULL;
 541             }
 542             else
 543             {
 544                 status = NetWkstaUserGetInfo(NULL, 1, (LPBYTE *)&ui);
 545                 if (status != NERR_Success || ui == NULL)
 546                 {
 547                     ret = SEC_E_NO_CREDENTIALS;
 548                     goto isc_end;
 549                 }
 550                 username = ntlm_GetUsernameArg(ui->wkui1_username, -1);
 551
 552                 FIXME("using ntlm_auth cached credentials not supported\n");
 553
 554                 client_argv[2] = username;
 555                 client_argv[3] = NULL;
 556                 client_argv[4] = NULL;
 557             }
 558         }
 559         else
 560         {
 561             client_argv[2] = ntlm_cred->username_arg;
 562             client_argv[3] = ntlm_cred->domain_arg;
 563             client_argv[4] = NULL;
 564         }
 565
 566         if((ret = fork_helper(&helper, ntlm_auth, client_argv)) != SEC_E_OK)
 567             goto isc_end;
 568
 569         helper->mode = NTLM_CLIENT;
 570         helper->session_key = HeapAlloc(GetProcessHeap(), 0, 16);
 571         if (!helper->session_key)
 572         {
 573             cleanup_helper(helper);
 574             ret = SEC_E_INSUFFICIENT_MEMORY;
 575             goto isc_end;
 576         }
 577
 578         /* Generate the dummy session key = MD4(MD4(password))*/
 579         if(password || ntlm_cred->password)
 580         {
 581             SEC_WCHAR *unicode_password;
 582             int passwd_lenW;
 583
 584             TRACE("Converting password to unicode.\n");
 585             passwd_lenW = MultiByteToWideChar(CP_ACP, 0,
 586                                               password ? password : ntlm_cred->password,
 587                                               password ? pwlen : ntlm_cred->pwlen,
 588                                               NULL, 0);
 589             unicode_password = HeapAlloc(GetProcessHeap(), 0,
 590                                          passwd_lenW * sizeof(SEC_WCHAR));
 591             MultiByteToWideChar(CP_ACP, 0, password ? password : ntlm_cred->password,
 592                                 password ? pwlen : ntlm_cred->pwlen, unicode_password, passwd_lenW);
 593
 594             SECUR32_CreateNTLMv1SessionKey((PBYTE)unicode_password,
 595                                            passwd_lenW * sizeof(SEC_WCHAR), helper->session_key);
 596
 597             HeapFree(GetProcessHeap(), 0, unicode_password);
 598         }
 599         else
 600             memset(helper->session_key, 0, 16);
 601
 602         /* Allocate space for a maximal string of
 603          * "SF NTLMSSP_FEATURE_SIGN NTLMSSP_FEATURE_SEAL
 604          * NTLMSSP_FEATURE_SESSION_KEY"
 605          */
 606         want_flags = HeapAlloc(GetProcessHeap(), 0, 73);
 607         if(want_flags == NULL)
 608         {
 609             cleanup_helper(helper);
 610             ret = SEC_E_INSUFFICIENT_MEMORY;
 611             goto isc_end;
 612         }
 613         lstrcpyA(want_flags, "SF");
 614         if(fContextReq & ISC_REQ_CONFIDENTIALITY)
 615         {
 616             if(strstr(want_flags, "NTLMSSP_FEATURE_SEAL") == NULL)
 617                 lstrcatA(want_flags, " NTLMSSP_FEATURE_SEAL");
 618         }
 619         if(fContextReq & ISC_REQ_CONNECTION)
 620             ctxt_attr |= ISC_RET_CONNECTION;
 621         if(fContextReq & ISC_REQ_EXTENDED_ERROR)
 622             ctxt_attr |= ISC_RET_EXTENDED_ERROR;
 623         if(fContextReq & ISC_REQ_INTEGRITY)
 624         {
 625             if(strstr(want_flags, "NTLMSSP_FEATURE_SIGN") == NULL)
 626                 lstrcatA(want_flags, " NTLMSSP_FEATURE_SIGN");
 627         }
 628         if(fContextReq & ISC_REQ_MUTUAL_AUTH)
 629             ctxt_attr |= ISC_RET_MUTUAL_AUTH;
 630         if(fContextReq & ISC_REQ_REPLAY_DETECT)
 631         {
 632             if(strstr(want_flags, "NTLMSSP_FEATURE_SIGN") == NULL)
 633                 lstrcatA(want_flags, " NTLMSSP_FEATURE_SIGN");
 634         }
 635         if(fContextReq & ISC_REQ_SEQUENCE_DETECT)
 636         {
 637             if(strstr(want_flags, "NTLMSSP_FEATURE_SIGN") == NULL)
 638                 lstrcatA(want_flags, " NTLMSSP_FEATURE_SIGN");
 639         }
 640         if(fContextReq & ISC_REQ_STREAM)
 641             FIXME("ISC_REQ_STREAM\n");
 642         if(fContextReq & ISC_REQ_USE_DCE_STYLE)
 643             ctxt_attr |= ISC_RET_USED_DCE_STYLE;
 644         if(fContextReq & ISC_REQ_DELEGATE)
 645             ctxt_attr |= ISC_RET_DELEGATE;
 646
 647         /* If no password is given, use an empty password instead. This is the
 648          * SMB way to do "anonymous" authentication. */
 649         if(!password && !ntlm_cred->password)
 650         {
 651             lstrcpynA(buffer, "OK", max_len-1);
 652             if((ret = run_helper(helper, buffer, max_len, &buffer_len)) != SEC_E_OK)
 653             {
 654                 cleanup_helper(helper);
 655                 goto isc_end;
 656             }
 657             /* If the helper replied with "PW", give an empty password. */
 658             if(!strncmp(buffer, "PW", 2))
 659             {
 660                 TRACE("Using cached credentials failed.\n");
 661                 lstrcpynA(buffer, "PW AA==", max_len-1);
 662             }
 663             else
 664             {
 665                 /* Just do a noop on the next run */
 666                 lstrcpynA(buffer, "OK", max_len-1);
 667             }
 668         }
 669         else
 670         {
 671             lstrcpynA(buffer, "PW ", max_len-1);
 672             if((ret = encodeBase64(password ? (unsigned char *)password : (unsigned char *)ntlm_cred->password,
 673                         password ? pwlen : ntlm_cred->pwlen, buffer+3,
 674                         max_len-3, &buffer_len)) != SEC_E_OK)
 675             {
 676                 cleanup_helper(helper);
 677                 goto isc_end;
 678             }
 679
 680         }
 681
 682         TRACE("Sending to helper: %s\n", debugstr_a(buffer));
 683         if((ret = run_helper(helper, buffer, max_len, &buffer_len)) != SEC_E_OK)
 684         {
 685             cleanup_helper(helper);
 686             goto isc_end;
 687         }
 688
 689         TRACE("Helper returned %s\n", debugstr_a(buffer));
 690
 691         if(lstrlenA(want_flags) > 2)
 692         {
 693             TRACE("Want flags are %s\n", debugstr_a(want_flags));
 694             lstrcpynA(buffer, want_flags, max_len-1);
 695             if((ret = run_helper(helper, buffer, max_len, &buffer_len))
 696                     != SEC_E_OK)
 697                 goto isc_end;
 698             if(!strncmp(buffer, "BH", 2))
 699                 ERR("Helper doesn't understand new command set. Expect more things to fail.\n");
 700         }
 701
 702         lstrcpynA(buffer, "YR", max_len-1);
 703
 704         if((ret = run_helper(helper, buffer, max_len, &buffer_len)) != SEC_E_OK)
 705         {
 706             cleanup_helper(helper);
 707             goto isc_end;
 708         }
 709
 710         TRACE("%s\n", buffer);
 711
 712         if(strncmp(buffer, "YR ", 3) != 0)
 713         {
 714             /* Something borked */
 715             TRACE("Helper returned %c%c\n", buffer[0], buffer[1]);
 716             ret = SEC_E_INTERNAL_ERROR;
 717             cleanup_helper(helper);
 718             goto isc_end;
 719         }
 720         if((ret = decodeBase64(buffer+3, buffer_len-3, bin,
 721                         max_len-1, &bin_len)) != SEC_E_OK)
 722         {
 723             cleanup_helper(helper);
 724             goto isc_end;
 725         }
 726
 727         /* put the decoded client blob into the out buffer */
 728
 729         phNewContext->dwUpper = ctxt_attr;
 730         phNewContext->dwLower = (ULONG_PTR)helper;
 731
 732         ret = SEC_I_CONTINUE_NEEDED;
 733     }
 734     else
 735     {
 736         int input_token_idx;
 737
 738         /* handle second call here */
 739         /* encode server data to base64 */
 740         if (!pInput || ((input_token_idx = ntlm_GetTokenBufferIndex(pInput)) == -1))
 741         {
 742             ret = SEC_E_INVALID_TOKEN;
 743             goto isc_end;
 744         }
 745
 746         if(!phContext)
 747         {
 748             ret = SEC_E_INVALID_HANDLE;
 749             goto isc_end;
 750         }
 751
 752         /* As the server side of sspi never calls this, make sure that
 753          * the handler is a client handler.
 754          */
 755         helper = (PNegoHelper)phContext->dwLower;
 756         if(helper->mode != NTLM_CLIENT)
 757         {
 758             TRACE("Helper mode = %d\n", helper->mode);
 759             ret = SEC_E_INVALID_HANDLE;
 760             goto isc_end;
 761         }
 762
 763         if (!pInput->pBuffers[input_token_idx].pvBuffer)
 764         {
 765             ret = SEC_E_INTERNAL_ERROR;
 766             goto isc_end;
 767         }
 768
 769         if(pInput->pBuffers[input_token_idx].cbBuffer > max_len)
 770         {
 771             TRACE("pInput->pBuffers[%d].cbBuffer is: %d\n",
 772                     input_token_idx,
 773                     pInput->pBuffers[input_token_idx].cbBuffer);
 774             ret = SEC_E_INVALID_TOKEN;
 775             goto isc_end;
 776         }
 777         else
 778             bin_len = pInput->pBuffers[input_token_idx].cbBuffer;
 779
 780         memcpy(bin, pInput->pBuffers[input_token_idx].pvBuffer, bin_len);
 781
 782         lstrcpynA(buffer, "TT ", max_len-1);
 783
 784         if((ret = encodeBase64(bin, bin_len, buffer+3,
 785                         max_len-3, &buffer_len)) != SEC_E_OK)
 786             goto isc_end;
 787
 788         TRACE("Server sent: %s\n", debugstr_a(buffer));
 789
 790         /* send TT base64 blob to ntlm_auth */
 791         if((ret = run_helper(helper, buffer, max_len, &buffer_len)) != SEC_E_OK)
 792             goto isc_end;
 793
 794         TRACE("Helper replied: %s\n", debugstr_a(buffer));
 795
 796         if( (strncmp(buffer, "KK ", 3) != 0) &&
 797                 (strncmp(buffer, "AF ", 3) !=0))
 798         {
 799             TRACE("Helper returned %c%c\n", buffer[0], buffer[1]);
 800             ret = SEC_E_INVALID_TOKEN;
 801             goto isc_end;
 802         }
 803
 804         /* decode the blob and send it to server */
 805         if((ret = decodeBase64(buffer+3, buffer_len-3, bin, max_len,
 806                         &bin_len)) != SEC_E_OK)
 807         {
 808             goto isc_end;
 809         }
 810
 811         phNewContext->dwUpper = ctxt_attr;
 812         phNewContext->dwLower = (ULONG_PTR)helper;
 813
 814         ret = SEC_E_OK;
 815     }
 816
 817     /* put the decoded client blob into the out buffer */
 818
 819     if (!pOutput || ((token_idx = ntlm_GetTokenBufferIndex(pOutput)) == -1))
 820     {
 821         TRACE("no SECBUFFER_TOKEN buffer could be found\n");
 822         ret = SEC_E_BUFFER_TOO_SMALL;
 823         if ((phContext == NULL) && (pInput == NULL))
 824         {
 825             cleanup_helper(helper);
 826             phNewContext->dwUpper = 0;
 827             phNewContext->dwLower = 0;
 828         }
 829         goto isc_end;
 830     }
 831
 832     if (fContextReq & ISC_REQ_ALLOCATE_MEMORY)
 833     {
 834         pOutput->pBuffers[token_idx].pvBuffer = HeapAlloc(GetProcessHeap(), 0, bin_len);
 835         pOutput->pBuffers[token_idx].cbBuffer = bin_len;
 836     }
 837     else if (pOutput->pBuffers[token_idx].cbBuffer < bin_len)
 838     {
 839         TRACE("out buffer is NULL or has not enough space\n");
 840         ret = SEC_E_BUFFER_TOO_SMALL;
 841         if ((phContext == NULL) && (pInput == NULL))
 842         {
 843             cleanup_helper(helper);
 844             phNewContext->dwUpper = 0;
 845             phNewContext->dwLower = 0;
 846         }
 847         goto isc_end;
 848     }
 849
 850     if (!pOutput->pBuffers[token_idx].pvBuffer)
 851     {
 852         TRACE("out buffer is NULL\n");
 853         ret = SEC_E_INTERNAL_ERROR;
 854         if ((phContext == NULL) && (pInput == NULL))
 855         {
 856             cleanup_helper(helper);
 857             phNewContext->dwUpper = 0;
 858             phNewContext->dwLower = 0;
 859         }
 860         goto isc_end;
 861     }
 862
 863     pOutput->pBuffers[token_idx].cbBuffer = bin_len;
 864     memcpy(pOutput->pBuffers[token_idx].pvBuffer, bin, bin_len);
 865
 866     if(ret == SEC_E_OK)
 867     {
 868         TRACE("Getting negotiated flags\n");
 869         lstrcpynA(buffer, "GF", max_len - 1);
 870         if((ret = run_helper(helper, buffer, max_len, &buffer_len)) != SEC_E_OK)
 871             goto isc_end;
 872
 873         if(buffer_len < 3)
 874         {
 875             TRACE("No flags negotiated.\n");
 876             helper->neg_flags = 0l;
 877         }
 878         else
 879         {
 880             TRACE("Negotiated %s\n", debugstr_a(buffer));
 881             sscanf(buffer + 3, "%lx", &(helper->neg_flags));
 882             TRACE("Stored 0x%08lx as flags\n", helper->neg_flags);
 883         }
 884
 885         TRACE("Getting session key\n");
 886         lstrcpynA(buffer, "GK", max_len - 1);
 887         if((ret = run_helper(helper, buffer, max_len, &buffer_len)) != SEC_E_OK)
 888             goto isc_end;
 889
 890         if(strncmp(buffer, "BH", 2) == 0)
 891             TRACE("No key negotiated.\n");
 892         else if(strncmp(buffer, "GK ", 3) == 0)
 893         {
 894             if((ret = decodeBase64(buffer+3, buffer_len-3, bin, max_len,
 895                             &bin_len)) != SEC_E_OK)
 896             {
 897                 TRACE("Failed to decode session key\n");
 898             }
 899             TRACE("Session key is %s\n", debugstr_a(buffer+3));
 900             HeapFree(GetProcessHeap(), 0, helper->session_key);
 901             helper->session_key = HeapAlloc(GetProcessHeap(), 0, bin_len);
 902             if(!helper->session_key)
 903             {
 904                 TRACE("Failed to allocate memory for session key\n");
 905                 ret = SEC_E_INTERNAL_ERROR;
 906                 goto isc_end;
 907             }
 908             memcpy(helper->session_key, bin, bin_len);
 909         }
 910
 911         helper->crypt.ntlm.a4i = SECUR32_arc4Alloc();
 912         SECUR32_arc4Init(helper->crypt.ntlm.a4i, helper->session_key, 16);
 913         helper->crypt.ntlm.seq_num = 0l;
 914         SECUR32_CreateNTLMv2SubKeys(helper);
 915         helper->crypt.ntlm2.send_a4i = SECUR32_arc4Alloc();
 916         helper->crypt.ntlm2.recv_a4i = SECUR32_arc4Alloc();
 917         SECUR32_arc4Init(helper->crypt.ntlm2.send_a4i,
 918                          helper->crypt.ntlm2.send_seal_key, 16);
 919         SECUR32_arc4Init(helper->crypt.ntlm2.recv_a4i,
 920                          helper->crypt.ntlm2.recv_seal_key, 16);
 921         helper->crypt.ntlm2.send_seq_no = 0l;
 922         helper->crypt.ntlm2.recv_seq_no = 0l;
 923     }
 924
 925 isc_end:
 926     HeapFree(GetProcessHeap(), 0, username);
 927     HeapFree(GetProcessHeap(), 0, domain);
 928     HeapFree(GetProcessHeap(), 0, password);
 929     HeapFree(GetProcessHeap(), 0, want_flags);
 930     HeapFree(GetProcessHeap(), 0, buffer);
 931     HeapFree(GetProcessHeap(), 0, bin);
 932     return ret;
 933 }
 934
 935 /***********************************************************************
 936  *              InitializeSecurityContextA
 937  */
 938 static SECURITY_STATUS SEC_ENTRY ntlm_InitializeSecurityContextA(
 939  PCredHandle phCredential, PCtxtHandle phContext, SEC_CHAR *pszTargetName,
 940  ULONG fContextReq, ULONG Reserved1, ULONG TargetDataRep,
 941  PSecBufferDesc pInput,ULONG Reserved2, PCtxtHandle phNewContext,
 942  PSecBufferDesc pOutput, ULONG *pfContextAttr, PTimeStamp ptsExpiry)
 943 {
 944     SECURITY_STATUS ret;
 945     SEC_WCHAR *target = NULL;
 946
 947     TRACE("%p %p %s %d %d %d %p %d %p %p %p %p\n", phCredential, phContext,
 948      debugstr_a(pszTargetName), fContextReq, Reserved1, TargetDataRep, pInput,
 949      Reserved1, phNewContext, pOutput, pfContextAttr, ptsExpiry);
 950
 951     if(pszTargetName != NULL)
 952     {
 953         int target_size = MultiByteToWideChar(CP_ACP, 0, pszTargetName,
 954             strlen(pszTargetName)+1, NULL, 0);
 955         target = HeapAlloc(GetProcessHeap(), 0, target_size *
 956                 sizeof(SEC_WCHAR));
 957         MultiByteToWideChar(CP_ACP, 0, pszTargetName, strlen(pszTargetName)+1,
 958             target, target_size);
 959     }
 960
 961     ret = ntlm_InitializeSecurityContextW(phCredential, phContext, target,
 962             fContextReq, Reserved1, TargetDataRep, pInput, Reserved2,
 963             phNewContext, pOutput, pfContextAttr, ptsExpiry);
 964
 965     HeapFree(GetProcessHeap(), 0, target);
 966     return ret;
 967 }
 968
 969 /***********************************************************************
 970  *              AcceptSecurityContext
 971  */
 972 static SECURITY_STATUS SEC_ENTRY ntlm_AcceptSecurityContext(
 973  PCredHandle phCredential, PCtxtHandle phContext, PSecBufferDesc pInput,
 974  ULONG fContextReq, ULONG TargetDataRep, PCtxtHandle phNewContext,
 975  PSecBufferDesc pOutput, ULONG *pfContextAttr, PTimeStamp ptsExpiry)
 976 {
 977     SECURITY_STATUS ret;
 978     char *buffer, *want_flags = NULL;
 979     PBYTE bin;
 980     int buffer_len, bin_len, max_len = NTLM_MAX_BUF;
 981     ULONG ctxt_attr = 0;
 982     PNegoHelper helper;
 983     PNtlmCredentials ntlm_cred;
 984
 985     TRACE("%p %p %p %d %d %p %p %p %p\n", phCredential, phContext, pInput,
 986      fContextReq, TargetDataRep, phNewContext, pOutput, pfContextAttr,
 987      ptsExpiry);
 988
 989     buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(char) * NTLM_MAX_BUF);
 990     bin    = HeapAlloc(GetProcessHeap(),0, sizeof(BYTE) * NTLM_MAX_BUF);
 991
 992     if(TargetDataRep == SECURITY_NETWORK_DREP){
 993         TRACE("Using SECURITY_NETWORK_DREP\n");
 994     }
 995
 996     if(phContext == NULL)
 997     {
 998         static CHAR server_helper_protocol[] = "--helper-protocol=squid-2.5-ntlmssp";
 999         SEC_CHAR *server_argv[] = { ntlm_auth,
1000             server_helper_protocol,
1001             NULL };
1002
1003         if (!phCredential)
1004         {
1005             ret = SEC_E_INVALID_HANDLE;
1006             goto asc_end;
1007         }
1008
1009         ntlm_cred = (PNtlmCredentials)phCredential->dwLower;
1010
1011         if(ntlm_cred->mode != NTLM_SERVER)
1012         {
1013             ret = SEC_E_INVALID_HANDLE;
1014             goto asc_end;
1015         }
1016
1017         /* This is the first call to AcceptSecurityHandle */
1018         if(pInput == NULL)
1019         {
1020             ret = SEC_E_INCOMPLETE_MESSAGE;
1021             goto asc_end;
1022         }
1023
1024         if(pInput->cBuffers < 1)
1025         {
1026             ret = SEC_E_INCOMPLETE_MESSAGE;
1027             goto asc_end;
1028         }
1029
1030         if(pInput->pBuffers[0].cbBuffer > max_len)
1031         {
1032             ret = SEC_E_INVALID_TOKEN;
1033             goto asc_end;
1034         }
1035         else
1036             bin_len = pInput->pBuffers[0].cbBuffer;
1037
1038         if( (ret = fork_helper(&helper, ntlm_auth, server_argv)) !=
1039             SEC_E_OK)
1040         {
1041             ret = SEC_E_INTERNAL_ERROR;
1042             goto asc_end;
1043         }
1044         helper->mode = NTLM_SERVER;
1045
1046         /* Handle all the flags */
1047         want_flags = HeapAlloc(GetProcessHeap(), 0, 73);
1048         if(want_flags == NULL)
1049         {
1050             TRACE("Failed to allocate memory for the want_flags!\n");
1051             ret = SEC_E_INSUFFICIENT_MEMORY;
1052             cleanup_helper(helper);
1053             goto asc_end;
1054         }
1055         lstrcpyA(want_flags, "SF");
1056         if(fContextReq & ASC_REQ_ALLOCATE_MEMORY)
1057         {
1058             FIXME("ASC_REQ_ALLOCATE_MEMORY stub\n");
1059         }
1060         if(fContextReq & ASC_REQ_CONFIDENTIALITY)
1061         {
1062             lstrcatA(want_flags, " NTLMSSP_FEATURE_SEAL");
1063         }
1064         if(fContextReq & ASC_REQ_CONNECTION)
1065         {
1066             /* This is default, so we'll enable it */
1067             lstrcatA(want_flags, " NTLMSSP_FEATURE_SESSION_KEY");
1068             ctxt_attr |= ASC_RET_CONNECTION;
1069         }
1070         if(fContextReq & ASC_REQ_EXTENDED_ERROR)
1071         {
1072             FIXME("ASC_REQ_EXTENDED_ERROR stub\n");
1073         }
1074         if(fContextReq & ASC_REQ_INTEGRITY)
1075         {
1076             lstrcatA(want_flags, " NTLMSSP_FEATURE_SIGN");
1077         }
1078         if(fContextReq & ASC_REQ_MUTUAL_AUTH)
1079         {
1080             FIXME("ASC_REQ_MUTUAL_AUTH stub\n");
1081         }
1082         if(fContextReq & ASC_REQ_REPLAY_DETECT)
1083         {
1084             FIXME("ASC_REQ_REPLAY_DETECT stub\n");
1085         }
1086         if(fContextReq & ISC_REQ_SEQUENCE_DETECT)
1087         {
1088             FIXME("ASC_REQ_SEQUENCE_DETECT stub\n");
1089         }
1090         if(fContextReq & ISC_REQ_STREAM)
1091         {
1092             FIXME("ASC_REQ_STREAM stub\n");
1093         }
1094         /* Done with the flags */
1095
1096         if(lstrlenA(want_flags) > 3)
1097         {
1098             TRACE("Server set want_flags: %s\n", debugstr_a(want_flags));
1099             lstrcpynA(buffer, want_flags, max_len - 1);
1100             if((ret = run_helper(helper, buffer, max_len, &buffer_len)) !=
1101                     SEC_E_OK)
1102             {
1103                 cleanup_helper(helper);
1104                 goto asc_end;
1105             }
1106             if(!strncmp(buffer, "BH", 2))
1107                 TRACE("Helper doesn't understand new command set\n");
1108         }
1109
1110         /* This is the YR request from the client, encode to base64 */
1111
1112         memcpy(bin, pInput->pBuffers[0].pvBuffer, bin_len);
1113
1114         lstrcpynA(buffer, "YR ", max_len-1);
1115
1116         if((ret = encodeBase64(bin, bin_len, buffer+3, max_len-3,
1117                     &buffer_len)) != SEC_E_OK)
1118         {
1119             cleanup_helper(helper);
1120             goto asc_end;
1121         }
1122
1123         TRACE("Client sent: %s\n", debugstr_a(buffer));
1124
1125         if((ret = run_helper(helper, buffer, max_len, &buffer_len)) !=
1126                     SEC_E_OK)
1127         {
1128             cleanup_helper(helper);
1129             goto asc_end;
1130         }
1131
1132         TRACE("Reply from ntlm_auth: %s\n", debugstr_a(buffer));
1133         /* The expected answer is TT <base64 blob> */
1134
1135         if(strncmp(buffer, "TT ", 3) != 0)
1136         {
1137             ret = SEC_E_INTERNAL_ERROR;
1138             cleanup_helper(helper);
1139             goto asc_end;
1140         }
1141
1142         if((ret = decodeBase64(buffer+3, buffer_len-3, bin, max_len,
1143                         &bin_len)) != SEC_E_OK)
1144         {
1145             cleanup_helper(helper);
1146             goto asc_end;
1147         }
1148
1149         /* send this to the client */
1150         if(pOutput == NULL)
1151         {
1152             ret = SEC_E_INSUFFICIENT_MEMORY;
1153             cleanup_helper(helper);
1154             goto asc_end;
1155         }
1156
1157         if(pOutput->cBuffers < 1)
1158         {
1159             ret = SEC_E_INSUFFICIENT_MEMORY;
1160             cleanup_helper(helper);
1161             goto asc_end;
1162         }
1163
1164         pOutput->pBuffers[0].cbBuffer = bin_len;
1165         pOutput->pBuffers[0].BufferType = SECBUFFER_DATA;
1166         memcpy(pOutput->pBuffers[0].pvBuffer, bin, bin_len);
1167         ret = SEC_I_CONTINUE_NEEDED;
1168
1169     }
1170     else
1171     {
1172         /* we expect a KK request from client */
1173         if(pInput == NULL)
1174         {
1175             ret = SEC_E_INCOMPLETE_MESSAGE;
1176             goto asc_end;
1177         }
1178
1179         if(pInput->cBuffers < 1)
1180         {
1181             ret = SEC_E_INCOMPLETE_MESSAGE;
1182             goto asc_end;
1183         }
1184
1185         if(!phContext)
1186         {
1187             ret = SEC_E_INVALID_HANDLE;
1188             goto asc_end;
1189         }
1190
1191         helper = (PNegoHelper)phContext->dwLower;
1192
1193         if(helper->mode != NTLM_SERVER)
1194         {
1195             ret = SEC_E_INVALID_HANDLE;
1196             goto asc_end;
1197         }
1198
1199         if(pInput->pBuffers[0].cbBuffer > max_len)
1200         {
1201             ret = SEC_E_INVALID_TOKEN;
1202             goto asc_end;
1203         }
1204         else
1205             bin_len = pInput->pBuffers[0].cbBuffer;
1206
1207         memcpy(bin, pInput->pBuffers[0].pvBuffer, bin_len);
1208
1209         lstrcpynA(buffer, "KK ", max_len-1);
1210
1211         if((ret = encodeBase64(bin, bin_len, buffer+3, max_len-3,
1212                     &buffer_len)) != SEC_E_OK)
1213         {
1214             goto asc_end;
1215         }
1216
1217         TRACE("Client sent: %s\n", debugstr_a(buffer));
1218
1219         if((ret = run_helper(helper, buffer, max_len, &buffer_len)) !=
1220                     SEC_E_OK)
1221         {
1222             goto asc_end;
1223         }
1224
1225         TRACE("Reply from ntlm_auth: %s\n", debugstr_a(buffer));
1226
1227         /* At this point, we get a NA if the user didn't authenticate, but a BH
1228          * if ntlm_auth could not connect to winbindd. Apart from running Wine
1229          * as root, there is no way to fix this for now, so just handle this as
1230          * a failed login. */
1231         if(strncmp(buffer, "AF ", 3) != 0)
1232         {
1233             if(strncmp(buffer, "NA ", 3) == 0)
1234             {
1235                 ret = SEC_E_LOGON_DENIED;
1236                 goto asc_end;
1237             }
1238             else
1239             {
1240                 size_t ntlm_pipe_err_len = strlen("BH NT_STATUS_ACCESS_DENIED");
1241
1242                 if( (buffer_len >= ntlm_pipe_err_len) &&
1243                     (strncmp(buffer, "BH NT_STATUS_ACCESS_DENIED",
1244                              ntlm_pipe_err_len) == 0))
1245                 {
1246                     TRACE("Connection to winbindd failed\n");
1247                     ret = SEC_E_LOGON_DENIED;
1248                 }
1249                 else
1250                     ret = SEC_E_INTERNAL_ERROR;
1251
1252                 goto asc_end;
1253             }
1254         }
1255         pOutput->pBuffers[0].cbBuffer = 0;
1256         ret = SEC_E_OK;
1257
1258         TRACE("Getting negotiated flags\n");
1259         lstrcpynA(buffer, "GF", max_len - 1);
1260         if((ret = run_helper(helper, buffer, max_len, &buffer_len)) != SEC_E_OK)
1261             goto asc_end;
1262
1263         if(buffer_len < 3)
1264         {
1265             TRACE("No flags negotiated, or helper does not support GF command\n");
1266         }
1267         else
1268         {
1269             TRACE("Negotiated %s\n", debugstr_a(buffer));
1270             sscanf(buffer + 3, "%lx", &(helper->neg_flags));
1271             TRACE("Stored 0x%08lx as flags\n", helper->neg_flags);
1272         }
1273
1274         TRACE("Getting session key\n");
1275         lstrcpynA(buffer, "GK", max_len - 1);
1276         if((ret = run_helper(helper, buffer, max_len, &buffer_len)) != SEC_E_OK)
1277             goto asc_end;
1278
1279         if(buffer_len < 3)
1280             TRACE("Helper does not support GK command\n");
1281         else
1282         {
1283             if(strncmp(buffer, "BH ", 3) == 0)
1284             {
1285                 TRACE("Helper sent %s\n", debugstr_a(buffer+3));
1286                 helper->session_key = HeapAlloc(GetProcessHeap(), 0, 16);
1287                 /*FIXME: Generate the dummy session key = MD4(MD4(password))*/
1288                 memset(helper->session_key, 0 , 16);
1289             }
1290             else if(strncmp(buffer, "GK ", 3) == 0)
1291             {
1292                 if((ret = decodeBase64(buffer+3, buffer_len-3, bin, max_len,
1293                                 &bin_len)) != SEC_E_OK)
1294                 {
1295                     TRACE("Failed to decode session key\n");
1296                 }
1297                 TRACE("Session key is %s\n", debugstr_a(buffer+3));
1298                 helper->session_key = HeapAlloc(GetProcessHeap(), 0, 16);
1299                 if(!helper->session_key)
1300                 {
1301                     TRACE("Failed to allocate memory for session key\n");
1302                     ret = SEC_E_INTERNAL_ERROR;
1303                     goto asc_end;
1304                 }
1305                 memcpy(helper->session_key, bin, 16);
1306             }
1307         }
1308         helper->crypt.ntlm.a4i = SECUR32_arc4Alloc();
1309         SECUR32_arc4Init(helper->crypt.ntlm.a4i, helper->session_key, 16);
1310         helper->crypt.ntlm.seq_num = 0l;
1311     }
1312
1313     phNewContext->dwUpper = ctxt_attr;
1314     phNewContext->dwLower = (ULONG_PTR)helper;
1315
1316 asc_end:
1317     HeapFree(GetProcessHeap(), 0, want_flags);
1318     HeapFree(GetProcessHeap(), 0, buffer);
1319     HeapFree(GetProcessHeap(), 0, bin);
1320     return ret;
1321 }
1322
1323 /***********************************************************************
1324  *              CompleteAuthToken
1325  */
1326 static SECURITY_STATUS SEC_ENTRY ntlm_CompleteAuthToken(PCtxtHandle phContext,
1327  PSecBufferDesc pToken)
1328 {
1329     /* We never need to call CompleteAuthToken anyway */
1330     TRACE("%p %p\n", phContext, pToken);
1331     if (!phContext)
1332         return SEC_E_INVALID_HANDLE;
1333
1334     return SEC_E_OK;
1335 }
1336
1337 /***********************************************************************
1338  *              DeleteSecurityContext
1339  */
1340 static SECURITY_STATUS SEC_ENTRY ntlm_DeleteSecurityContext(PCtxtHandle phContext)
1341 {
1342     PNegoHelper helper;
1343
1344     TRACE("%p\n", phContext);
1345     if (!phContext)
1346         return SEC_E_INVALID_HANDLE;
1347
1348     helper = (PNegoHelper)phContext->dwLower;
1349
1350     phContext->dwUpper = 0;
1351     phContext->dwLower = 0;
1352
1353     SECUR32_arc4Cleanup(helper->crypt.ntlm.a4i);
1354     HeapFree(GetProcessHeap(), 0, helper->session_key);
1355     SECUR32_arc4Cleanup(helper->crypt.ntlm2.send_a4i);
1356     SECUR32_arc4Cleanup(helper->crypt.ntlm2.recv_a4i);
1357     HeapFree(GetProcessHeap(), 0, helper->crypt.ntlm2.send_sign_key);
1358     HeapFree(GetProcessHeap(), 0, helper->crypt.ntlm2.send_seal_key);
1359     HeapFree(GetProcessHeap(), 0, helper->crypt.ntlm2.recv_sign_key);
1360     HeapFree(GetProcessHeap(), 0, helper->crypt.ntlm2.recv_seal_key);
1361
1362     cleanup_helper(helper);
1363
1364     return SEC_E_OK;
1365 }
1366
1367 /***********************************************************************
1368  *              QueryContextAttributesW
1369  */
1370 static SECURITY_STATUS SEC_ENTRY ntlm_QueryContextAttributesW(PCtxtHandle phContext,
1371  ULONG ulAttribute, void *pBuffer)
1372 {
1373     TRACE("%p %d %p\n", phContext, ulAttribute, pBuffer);
1374     if (!phContext)
1375         return SEC_E_INVALID_HANDLE;
1376
1377     switch(ulAttribute)
1378     {
1379 #define _x(x) case (x) : FIXME(#x" stub\n"); break
1380         _x(SECPKG_ATTR_ACCESS_TOKEN);
1381         _x(SECPKG_ATTR_AUTHORITY);
1382         _x(SECPKG_ATTR_DCE_INFO);
1383         case SECPKG_ATTR_FLAGS:
1384         {
1385             PSecPkgContext_Flags spcf = (PSecPkgContext_Flags)pBuffer;
1386             PNegoHelper helper = (PNegoHelper)phContext->dwLower;
1387
1388             spcf->Flags = 0;
1389             if(helper->neg_flags & NTLMSSP_NEGOTIATE_SIGN)
1390                 spcf->Flags |= ISC_RET_INTEGRITY;
1391             if(helper->neg_flags & NTLMSSP_NEGOTIATE_SEAL)
1392                 spcf->Flags |= ISC_RET_CONFIDENTIALITY;
1393             return SEC_E_OK;
1394         }
1395         _x(SECPKG_ATTR_KEY_INFO);
1396         _x(SECPKG_ATTR_LIFESPAN);
1397         _x(SECPKG_ATTR_NAMES);
1398         _x(SECPKG_ATTR_NATIVE_NAMES);
1399         _x(SECPKG_ATTR_NEGOTIATION_INFO);
1400         _x(SECPKG_ATTR_PACKAGE_INFO);
1401         _x(SECPKG_ATTR_PASSWORD_EXPIRY);
1402         _x(SECPKG_ATTR_SESSION_KEY);
1403         case SECPKG_ATTR_SIZES:
1404         {
1405             PSecPkgContext_Sizes spcs = (PSecPkgContext_Sizes)pBuffer;
1406             spcs->cbMaxToken = NTLM_MAX_BUF;
1407             spcs->cbMaxSignature = 16;
1408             spcs->cbBlockSize = 0;
1409             spcs->cbSecurityTrailer = 16;
1410             return SEC_E_OK;
1411         }
1412         _x(SECPKG_ATTR_STREAM_SIZES);
1413         _x(SECPKG_ATTR_TARGET_INFORMATION);
1414 #undef _x
1415         default:
1416             TRACE("Unknown value %d passed for ulAttribute\n", ulAttribute);
1417     }
1418
1419     return SEC_E_UNSUPPORTED_FUNCTION;
1420 }
1421
1422 /***********************************************************************
1423  *              QueryContextAttributesA
1424  */
1425 static SECURITY_STATUS SEC_ENTRY ntlm_QueryContextAttributesA(PCtxtHandle phContext,
1426  ULONG ulAttribute, void *pBuffer)
1427 {
1428     return ntlm_QueryContextAttributesW(phContext, ulAttribute, pBuffer);
1429 }
1430
1431 /***********************************************************************
1432  *              ImpersonateSecurityContext
1433  */
1434 static SECURITY_STATUS SEC_ENTRY ntlm_ImpersonateSecurityContext(PCtxtHandle phContext)
1435 {
1436     SECURITY_STATUS ret;
1437
1438     TRACE("%p\n", phContext);
1439     if (phContext)
1440     {
1441         ret = SEC_E_UNSUPPORTED_FUNCTION;
1442     }
1443     else
1444     {
1445         ret = SEC_E_INVALID_HANDLE;
1446     }
1447     return ret;
1448 }
1449
1450 /***********************************************************************
1451  *              RevertSecurityContext
1452  */
1453 static SECURITY_STATUS SEC_ENTRY ntlm_RevertSecurityContext(PCtxtHandle phContext)
1454 {
1455     SECURITY_STATUS ret;
1456
1457     TRACE("%p\n", phContext);
1458     if (phContext)
1459     {
1460         ret = SEC_E_UNSUPPORTED_FUNCTION;
1461     }
1462     else
1463     {
1464         ret = SEC_E_INVALID_HANDLE;
1465     }
1466     return ret;
1467 }
1468
1469 /***********************************************************************
1470  *             ntlm_CreateSignature
1471  * As both MakeSignature and VerifySignature need this, but different keys
1472  * are needed for NTLMv2, the logic goes into a helper function.
1473  * To ensure maximal reusability, we can specify the direction as NTLM_SEND for
1474  * signing/encrypting and NTLM_RECV for verfying/decrypting. When encrypting,
1475  * the signature is encrypted after the message was encrypted, so
1476  * CreateSignature shouldn't do it. In this case, encrypt_sig can be set to
1477  * false.
1478  */
1479 static SECURITY_STATUS ntlm_CreateSignature(PNegoHelper helper, PSecBufferDesc pMessage,
1480         int token_idx, SignDirection direction, BOOL encrypt_sig)
1481 {
1482     ULONG sign_version = 1;
1483     UINT i;
1484     PBYTE sig;
1485     TRACE("%p, %p, %d, %d, %d\n", helper, pMessage, token_idx, direction,
1486             encrypt_sig);
1487
1488     sig = pMessage->pBuffers[token_idx].pvBuffer;
1489
1490     if(helper->neg_flags & NTLMSSP_NEGOTIATE_NTLM2 &&
1491             helper->neg_flags & NTLMSSP_NEGOTIATE_SIGN)
1492     {
1493         BYTE digest[16];
1494         BYTE seq_no[4];
1495         HMAC_MD5_CTX hmac_md5_ctx;
1496
1497         TRACE("Signing NTLM2 style\n");
1498
1499         if(direction == NTLM_SEND)
1500         {
1501             seq_no[0] = (helper->crypt.ntlm2.send_seq_no >>  0) & 0xff;
1502             seq_no[1] = (helper->crypt.ntlm2.send_seq_no >>  8) & 0xff;
1503             seq_no[2] = (helper->crypt.ntlm2.send_seq_no >> 16) & 0xff;
1504             seq_no[3] = (helper->crypt.ntlm2.send_seq_no >> 24) & 0xff;
1505
1506             ++(helper->crypt.ntlm2.send_seq_no);
1507
1508             HMACMD5Init(&hmac_md5_ctx, helper->crypt.ntlm2.send_sign_key, 16);
1509         }
1510         else
1511         {
1512             seq_no[0] = (helper->crypt.ntlm2.recv_seq_no >>  0) & 0xff;
1513             seq_no[1] = (helper->crypt.ntlm2.recv_seq_no >>  8) & 0xff;
1514             seq_no[2] = (helper->crypt.ntlm2.recv_seq_no >> 16) & 0xff;
1515             seq_no[3] = (helper->crypt.ntlm2.recv_seq_no >> 24) & 0xff;
1516
1517             ++(helper->crypt.ntlm2.recv_seq_no);
1518
1519             HMACMD5Init(&hmac_md5_ctx, helper->crypt.ntlm2.recv_sign_key, 16);
1520         }
1521
1522         HMACMD5Update(&hmac_md5_ctx, seq_no, 4);
1523         for( i = 0; i < pMessage->cBuffers; ++i )
1524         {
1525             if(pMessage->pBuffers[i].BufferType & SECBUFFER_DATA)
1526                 HMACMD5Update(&hmac_md5_ctx, pMessage->pBuffers[i].pvBuffer,
1527                         pMessage->pBuffers[i].cbBuffer);
1528         }
1529
1530         HMACMD5Final(&hmac_md5_ctx, digest);
1531
1532         if(encrypt_sig && helper->neg_flags & NTLMSSP_NEGOTIATE_KEY_EXCHANGE)
1533         {
1534             if(direction == NTLM_SEND)
1535                 SECUR32_arc4Process(helper->crypt.ntlm2.send_a4i, digest, 8);
1536             else
1537                 SECUR32_arc4Process(helper->crypt.ntlm2.recv_a4i, digest, 8);
1538         }
1539
1540         /* The NTLM2 signature is the sign version */
1541         sig[ 0] = (sign_version >>  0) & 0xff;
1542         sig[ 1] = (sign_version >>  8) & 0xff;
1543         sig[ 2] = (sign_version >> 16) & 0xff;
1544         sig[ 3] = (sign_version >> 24) & 0xff;
1545         /* The first 8 bytes of the digest */
1546         memcpy(sig+4, digest, 8);
1547         /* And the sequence number */
1548         memcpy(sig+12, seq_no, 4);
1549
1550         pMessage->pBuffers[token_idx].cbBuffer = 16;
1551
1552         return SEC_E_OK;
1553     }
1554     if(helper->neg_flags & NTLMSSP_NEGOTIATE_SIGN)
1555     {
1556         ULONG crc = 0U;
1557         TRACE("Signing NTLM1 style\n");
1558
1559         for(i=0; i < pMessage->cBuffers; ++i)
1560         {
1561             if(pMessage->pBuffers[i].BufferType & SECBUFFER_DATA)
1562             {
1563                 crc = ComputeCrc32(pMessage->pBuffers[i].pvBuffer,
1564                     pMessage->pBuffers[i].cbBuffer, crc);
1565             }
1566         }
1567
1568         sig[ 0] = (sign_version >>  0) & 0xff;
1569         sig[ 1] = (sign_version >>  8) & 0xff;
1570         sig[ 2] = (sign_version >> 16) & 0xff;
1571         sig[ 3] = (sign_version >> 24) & 0xff;
1572         memset(sig+4, 0, 4);
1573         sig[ 8] = (crc >>  0) & 0xff;
1574         sig[ 9] = (crc >>  8) & 0xff;
1575         sig[10] = (crc >> 16) & 0xff;
1576         sig[11] = (crc >> 24) & 0xff;
1577         sig[12] = (helper->crypt.ntlm.seq_num >>  0) & 0xff;
1578         sig[13] = (helper->crypt.ntlm.seq_num >>  8) & 0xff;
1579         sig[14] = (helper->crypt.ntlm.seq_num >> 16) & 0xff;
1580         sig[15] = (helper->crypt.ntlm.seq_num >> 24) & 0xff;
1581
1582         ++(helper->crypt.ntlm.seq_num);
1583
1584         if(encrypt_sig)
1585             SECUR32_arc4Process(helper->crypt.ntlm.a4i, sig+4, 12);
1586         return SEC_E_OK;
1587     }
1588
1589     if(helper->neg_flags & NTLMSSP_NEGOTIATE_ALWAYS_SIGN || helper->neg_flags == 0)
1590     {
1591         TRACE("Creating a dummy signature.\n");
1592         /* A dummy signature is 0x01 followed by 15 bytes of 0x00 */
1593         memset(pMessage->pBuffers[token_idx].pvBuffer, 0, 16);
1594         memset(pMessage->pBuffers[token_idx].pvBuffer, 0x01, 1);
1595         pMessage->pBuffers[token_idx].cbBuffer = 16;
1596         return SEC_E_OK;
1597     }
1598
1599     return SEC_E_UNSUPPORTED_FUNCTION;
1600 }
1601
1602 /***********************************************************************
1603  *              MakeSignature
1604  */
1605 static SECURITY_STATUS SEC_ENTRY ntlm_MakeSignature(PCtxtHandle phContext, ULONG fQOP,
1606  PSecBufferDesc pMessage, ULONG MessageSeqNo)
1607 {
1608     PNegoHelper helper;
1609     int token_idx;
1610
1611     TRACE("%p %d %p %d\n", phContext, fQOP, pMessage, MessageSeqNo);
1612     if (!phContext)
1613         return SEC_E_INVALID_HANDLE;
1614
1615     if(fQOP)
1616         FIXME("Ignoring fQOP 0x%08x\n", fQOP);
1617
1618     if(MessageSeqNo)
1619         FIXME("Ignoring MessageSeqNo\n");
1620
1621     if(!pMessage || !pMessage->pBuffers || pMessage->cBuffers < 2)
1622         return SEC_E_INVALID_TOKEN;
1623
1624     /* If we didn't find a SECBUFFER_TOKEN type buffer */
1625     if((token_idx = ntlm_GetTokenBufferIndex(pMessage)) == -1)
1626         return SEC_E_INVALID_TOKEN;
1627
1628     if(pMessage->pBuffers[token_idx].cbBuffer < 16)
1629         return SEC_E_BUFFER_TOO_SMALL;
1630
1631     helper = (PNegoHelper)phContext->dwLower;
1632     TRACE("Negotiated flags are: 0x%08lx\n", helper->neg_flags);
1633
1634     return ntlm_CreateSignature(helper, pMessage, token_idx, NTLM_SEND, TRUE);
1635 }
1636
1637 /***********************************************************************
1638  *              VerifySignature
1639  */
1640 static SECURITY_STATUS SEC_ENTRY ntlm_VerifySignature(PCtxtHandle phContext,
1641  PSecBufferDesc pMessage, ULONG MessageSeqNo, PULONG pfQOP)
1642 {
1643     PNegoHelper helper;
1644     ULONG fQOP = 0;
1645     UINT i;
1646     int token_idx;
1647     SECURITY_STATUS ret;
1648     SecBufferDesc local_desc;
1649     PSecBuffer     local_buff;
1650     BYTE          local_sig[16];
1651
1652     TRACE("%p %p %d %p\n", phContext, pMessage, MessageSeqNo, pfQOP);
1653     if(!phContext)
1654         return SEC_E_INVALID_HANDLE;
1655
1656     if(!pMessage || !pMessage->pBuffers || pMessage->cBuffers < 2)
1657         return SEC_E_INVALID_TOKEN;
1658
1659     if((token_idx = ntlm_GetTokenBufferIndex(pMessage)) == -1)
1660         return SEC_E_INVALID_TOKEN;
1661
1662     if(pMessage->pBuffers[token_idx].cbBuffer < 16)
1663         return SEC_E_BUFFER_TOO_SMALL;
1664
1665     if(MessageSeqNo)
1666         FIXME("Ignoring MessageSeqNo\n");
1667
1668     helper = (PNegoHelper)phContext->dwLower;
1669     TRACE("Negotiated flags: 0x%08lx\n", helper->neg_flags);
1670
1671     local_buff = HeapAlloc(GetProcessHeap(), 0, pMessage->cBuffers * sizeof(SecBuffer));
1672
1673     local_desc.ulVersion = SECBUFFER_VERSION;
1674     local_desc.cBuffers = pMessage->cBuffers;
1675     local_desc.pBuffers = local_buff;
1676
1677     for(i=0; i < pMessage->cBuffers; ++i)
1678     {
1679         if(pMessage->pBuffers[i].BufferType == SECBUFFER_TOKEN)
1680         {
1681             local_buff[i].BufferType = SECBUFFER_TOKEN;
1682             local_buff[i].cbBuffer = 16;
1683             local_buff[i].pvBuffer = local_sig;
1684         }
1685         else
1686         {
1687             local_buff[i].BufferType = pMessage->pBuffers[i].BufferType;
1688             local_buff[i].cbBuffer = pMessage->pBuffers[i].cbBuffer;
1689             local_buff[i].pvBuffer = pMessage->pBuffers[i].pvBuffer;
1690         }
1691     }
1692
1693     if((ret = ntlm_CreateSignature(helper, &local_desc, token_idx, NTLM_RECV, TRUE)) != SEC_E_OK)
1694         return ret;
1695
1696     if(memcmp(((PBYTE)local_buff[token_idx].pvBuffer) + 8,
1697                 ((PBYTE)pMessage->pBuffers[token_idx].pvBuffer) + 8, 8))
1698         ret = SEC_E_MESSAGE_ALTERED;
1699     else
1700         ret = SEC_E_OK;
1701
1702     HeapFree(GetProcessHeap(), 0, local_buff);
1703     pfQOP = &fQOP;
1704
1705     return ret;
1706
1707 }
1708
1709 /***********************************************************************
1710  *             FreeCredentialsHandle
1711  */
1712 static SECURITY_STATUS SEC_ENTRY ntlm_FreeCredentialsHandle(
1713         PCredHandle phCredential)
1714 {
1715     SECURITY_STATUS ret;
1716
1717     if(phCredential){
1718         PNtlmCredentials ntlm_cred = (PNtlmCredentials) phCredential->dwLower;
1719         phCredential->dwUpper = 0;
1720         phCredential->dwLower = 0;
1721         if (ntlm_cred->password)
1722             memset(ntlm_cred->password, 0, ntlm_cred->pwlen);
1723         HeapFree(GetProcessHeap(), 0, ntlm_cred->password);
1724         HeapFree(GetProcessHeap(), 0, ntlm_cred->username_arg);
1725         HeapFree(GetProcessHeap(), 0, ntlm_cred->domain_arg);
1726         ret = SEC_E_OK;
1727     }
1728     else
1729         ret = SEC_E_OK;
1730
1731     return ret;
1732 }
1733
1734 /***********************************************************************
1735  *             EncryptMessage
1736  */
1737 static SECURITY_STATUS SEC_ENTRY ntlm_EncryptMessage(PCtxtHandle phContext,
1738         ULONG fQOP, PSecBufferDesc pMessage, ULONG MessageSeqNo)
1739 {
1740     PNegoHelper helper;
1741     int token_idx, data_idx;
1742
1743     TRACE("(%p %d %p %d)\n", phContext, fQOP, pMessage, MessageSeqNo);
1744
1745     if(!phContext)
1746         return SEC_E_INVALID_HANDLE;
1747
1748     if(fQOP)
1749         FIXME("Ignoring fQOP\n");
1750
1751     if(MessageSeqNo)
1752         FIXME("Ignoring MessageSeqNo\n");
1753
1754     if(!pMessage || !pMessage->pBuffers || pMessage->cBuffers < 2)
1755         return SEC_E_INVALID_TOKEN;
1756
1757     if((token_idx = ntlm_GetTokenBufferIndex(pMessage)) == -1)
1758         return SEC_E_INVALID_TOKEN;
1759
1760     if((data_idx = ntlm_GetDataBufferIndex(pMessage)) ==-1 )
1761         return SEC_E_INVALID_TOKEN;
1762
1763     if(pMessage->pBuffers[token_idx].cbBuffer < 16)
1764         return SEC_E_BUFFER_TOO_SMALL;
1765
1766     helper = (PNegoHelper) phContext->dwLower;
1767
1768     if(helper->neg_flags & NTLMSSP_NEGOTIATE_NTLM2 &&
1769             helper->neg_flags & NTLMSSP_NEGOTIATE_SEAL)
1770     {
1771         ntlm_CreateSignature(helper, pMessage, token_idx, NTLM_SEND, FALSE);
1772         SECUR32_arc4Process(helper->crypt.ntlm2.send_a4i,
1773                 pMessage->pBuffers[data_idx].pvBuffer,
1774                 pMessage->pBuffers[data_idx].cbBuffer);
1775
1776         if(helper->neg_flags & NTLMSSP_NEGOTIATE_KEY_EXCHANGE)
1777             SECUR32_arc4Process(helper->crypt.ntlm2.send_a4i,
1778                     ((BYTE *)pMessage->pBuffers[token_idx].pvBuffer)+4, 8);
1779
1780
1781         return SEC_E_OK;
1782     }
1783     else
1784     {
1785         PBYTE sig;
1786         ULONG save_flags;
1787
1788         /* EncryptMessage always produces real signatures, so make sure
1789          * NTLMSSP_NEGOTIATE_SIGN is set*/
1790         save_flags = helper->neg_flags;
1791         helper->neg_flags |= NTLMSSP_NEGOTIATE_SIGN;
1792         ntlm_CreateSignature(helper, pMessage, token_idx, NTLM_SEND, FALSE);
1793         helper->neg_flags = save_flags;
1794
1795         sig = pMessage->pBuffers[token_idx].pvBuffer;
1796
1797         SECUR32_arc4Process(helper->crypt.ntlm.a4i,
1798                 pMessage->pBuffers[data_idx].pvBuffer,
1799                 pMessage->pBuffers[data_idx].cbBuffer);
1800         SECUR32_arc4Process(helper->crypt.ntlm.a4i, sig+4, 12);
1801
1802         if(helper->neg_flags & NTLMSSP_NEGOTIATE_ALWAYS_SIGN || helper->neg_flags == 0)
1803             memset(sig+4, 0, 4);
1804
1805     }
1806
1807     return SEC_E_OK;
1808 }
1809
1810 /***********************************************************************
1811  *             DecryptMessage
1812  */
1813 static SECURITY_STATUS SEC_ENTRY ntlm_DecryptMessage(PCtxtHandle phContext,
1814         PSecBufferDesc pMessage, ULONG MessageSeqNo, PULONG pfQOP)
1815 {
1816     SECURITY_STATUS ret;
1817     ULONG ntlmssp_flags_save;
1818     PNegoHelper helper;
1819     int token_idx, data_idx;
1820     TRACE("(%p %p %d %p)\n", phContext, pMessage, MessageSeqNo, pfQOP);
1821
1822     if(!phContext)
1823         return SEC_E_INVALID_HANDLE;
1824
1825     if(MessageSeqNo)
1826         FIXME("Ignoring MessageSeqNo\n");
1827
1828     if(!pMessage || !pMessage->pBuffers || pMessage->cBuffers < 2)
1829         return SEC_E_INVALID_TOKEN;
1830
1831     if((token_idx = ntlm_GetTokenBufferIndex(pMessage)) == -1)
1832         return SEC_E_INVALID_TOKEN;
1833
1834     if((data_idx = ntlm_GetDataBufferIndex(pMessage)) ==-1)
1835         return SEC_E_INVALID_TOKEN;
1836
1837     if(pMessage->pBuffers[token_idx].cbBuffer < 16)
1838         return SEC_E_BUFFER_TOO_SMALL;
1839
1840     helper = (PNegoHelper) phContext->dwLower;
1841
1842     if(helper->neg_flags & NTLMSSP_NEGOTIATE_NTLM2 && helper->neg_flags & NTLMSSP_NEGOTIATE_SEAL)
1843     {
1844         SECUR32_arc4Process(helper->crypt.ntlm2.recv_a4i,
1845                 pMessage->pBuffers[data_idx].pvBuffer,
1846                 pMessage->pBuffers[data_idx].cbBuffer);
1847     }
1848     else
1849     {
1850         SECUR32_arc4Process(helper->crypt.ntlm.a4i,
1851                 pMessage->pBuffers[data_idx].pvBuffer,
1852                 pMessage->pBuffers[data_idx].cbBuffer);
1853     }
1854
1855     /* Make sure we use a session key for the signature check, EncryptMessage
1856      * always does that, even in the dummy case */
1857     ntlmssp_flags_save = helper->neg_flags;
1858
1859     helper->neg_flags |= NTLMSSP_NEGOTIATE_SIGN;
1860     ret = ntlm_VerifySignature(phContext, pMessage, MessageSeqNo, pfQOP);
1861
1862     helper->neg_flags = ntlmssp_flags_save;
1863
1864     return ret;
1865 }
1866
1867 static const SecurityFunctionTableA ntlmTableA = {
1868     1,
1869     NULL,   /* EnumerateSecurityPackagesA */
1870     ntlm_QueryCredentialsAttributesA,   /* QueryCredentialsAttributesA */
1871     ntlm_AcquireCredentialsHandleA,     /* AcquireCredentialsHandleA */
1872     ntlm_FreeCredentialsHandle,         /* FreeCredentialsHandle */
1873     NULL,   /* Reserved2 */
1874     ntlm_InitializeSecurityContextA,    /* InitializeSecurityContextA */
1875     ntlm_AcceptSecurityContext,         /* AcceptSecurityContext */
1876     ntlm_CompleteAuthToken,             /* CompleteAuthToken */
1877     ntlm_DeleteSecurityContext,         /* DeleteSecurityContext */
1878     NULL,  /* ApplyControlToken */
1879     ntlm_QueryContextAttributesA,       /* QueryContextAttributesA */
1880     ntlm_ImpersonateSecurityContext,    /* ImpersonateSecurityContext */
1881     ntlm_RevertSecurityContext,         /* RevertSecurityContext */
1882     ntlm_MakeSignature,                 /* MakeSignature */
1883     ntlm_VerifySignature,               /* VerifySignature */
1884     FreeContextBuffer,                  /* FreeContextBuffer */
1885     NULL,   /* QuerySecurityPackageInfoA */
1886     NULL,   /* Reserved3 */
1887     NULL,   /* Reserved4 */
1888     NULL,   /* ExportSecurityContext */
1889     NULL,   /* ImportSecurityContextA */
1890     NULL,   /* AddCredentialsA */
1891     NULL,   /* Reserved8 */
1892     NULL,   /* QuerySecurityContextToken */
1893     ntlm_EncryptMessage,                /* EncryptMessage */
1894     ntlm_DecryptMessage,                /* DecryptMessage */
1895     NULL,   /* SetContextAttributesA */
1896 };
1897
1898 static const SecurityFunctionTableW ntlmTableW = {
1899     1,
1900     NULL,   /* EnumerateSecurityPackagesW */
1901     ntlm_QueryCredentialsAttributesW,   /* QueryCredentialsAttributesW */
1902     ntlm_AcquireCredentialsHandleW,     /* AcquireCredentialsHandleW */
1903     ntlm_FreeCredentialsHandle,         /* FreeCredentialsHandle */
1904     NULL,   /* Reserved2 */
1905     ntlm_InitializeSecurityContextW,    /* InitializeSecurityContextW */
1906     ntlm_AcceptSecurityContext,         /* AcceptSecurityContext */
1907     ntlm_CompleteAuthToken,             /* CompleteAuthToken */
1908     ntlm_DeleteSecurityContext,         /* DeleteSecurityContext */
1909     NULL,  /* ApplyControlToken */
1910     ntlm_QueryContextAttributesW,       /* QueryContextAttributesW */
1911     ntlm_ImpersonateSecurityContext,    /* ImpersonateSecurityContext */
1912     ntlm_RevertSecurityContext,         /* RevertSecurityContext */
1913     ntlm_MakeSignature,                 /* MakeSignature */
1914     ntlm_VerifySignature,               /* VerifySignature */
1915     FreeContextBuffer,                  /* FreeContextBuffer */
1916     NULL,   /* QuerySecurityPackageInfoW */
1917     NULL,   /* Reserved3 */
1918     NULL,   /* Reserved4 */
1919     NULL,   /* ExportSecurityContext */
1920     NULL,   /* ImportSecurityContextW */
1921     NULL,   /* AddCredentialsW */
1922     NULL,   /* Reserved8 */
1923     NULL,   /* QuerySecurityContextToken */
1924     ntlm_EncryptMessage,                /* EncryptMessage */
1925     ntlm_DecryptMessage,                /* DecryptMessage */
1926     NULL,   /* SetContextAttributesW */
1927 };
1928
1929 #define NTLM_COMMENT \
1930    { 'N', 'T', 'L', 'M', ' ', \
1931      'S', 'e', 'c', 'u', 'r', 'i', 't', 'y', ' ', \
1932      'P', 'a', 'c', 'k', 'a', 'g', 'e', 0}
1933
1934 static CHAR ntlm_comment_A[] = NTLM_COMMENT;
1935 static WCHAR ntlm_comment_W[] = NTLM_COMMENT;
1936
1937 #define NTLM_NAME {'N', 'T', 'L', 'M', 0}
1938
1939 static char ntlm_name_A[] = NTLM_NAME;
1940 static WCHAR ntlm_name_W[] = NTLM_NAME;
1941
1942 /* According to Windows, NTLM has the following capabilities.  */
1943 #define CAPS ( \
1944         SECPKG_FLAG_INTEGRITY | \
1945         SECPKG_FLAG_PRIVACY | \
1946         SECPKG_FLAG_TOKEN_ONLY | \
1947         SECPKG_FLAG_CONNECTION | \
1948         SECPKG_FLAG_MULTI_REQUIRED | \
1949         SECPKG_FLAG_IMPERSONATION | \
1950         SECPKG_FLAG_ACCEPT_WIN32_NAME | \
1951         SECPKG_FLAG_READONLY_WITH_CHECKSUM)
1952
1953 static const SecPkgInfoW infoW = {
1954     CAPS,
1955     1,
1956     RPC_C_AUTHN_WINNT,
1957     NTLM_MAX_BUF,
1958     ntlm_name_W,
1959     ntlm_comment_W
1960 };
1961
1962 static const SecPkgInfoA infoA = {
1963     CAPS,
1964     1,
1965     RPC_C_AUTHN_WINNT,
1966     NTLM_MAX_BUF,
1967     ntlm_name_A,
1968     ntlm_comment_A
1969 };
1970
1971 void SECUR32_initNTLMSP(void)
1972 {
1973     PNegoHelper helper;
1974     static CHAR version[] = "--version";
1975
1976     SEC_CHAR *args[] = {
1977         ntlm_auth,
1978         version,
1979         NULL };
1980
1981     if(fork_helper(&helper, ntlm_auth, args) != SEC_E_OK)
1982     {
1983         /* Cheat and allocate a helper anyway, so cleanup later will work. */
1984         helper = HeapAlloc(GetProcessHeap(),0, sizeof(NegoHelper));
1985         helper->major = helper->minor = helper->micro = -1;
1986         helper->pipe_in = helper->pipe_out = -1;
1987     }
1988     else
1989         check_version(helper);
1990
1991     if( (helper->major >  MIN_NTLM_AUTH_MAJOR_VERSION) ||
1992         (helper->major == MIN_NTLM_AUTH_MAJOR_VERSION  &&
1993          helper->minor >  MIN_NTLM_AUTH_MINOR_VERSION) ||
1994         (helper->major == MIN_NTLM_AUTH_MAJOR_VERSION  &&
1995          helper->minor == MIN_NTLM_AUTH_MINOR_VERSION  &&
1996          helper->micro >= MIN_NTLM_AUTH_MICRO_VERSION) )
1997     {
1998         SecureProvider *provider = SECUR32_addProvider(&ntlmTableA, &ntlmTableW, NULL);
1999         SECUR32_addPackages(provider, 1L, &infoA, &infoW);
2000     }
2001     else
2002     {
2003         ERR("%s was not found or is outdated. "
2004             "Make sure that ntlm_auth >= %d.%d.%d is in your path.\n",
2005             ntlm_auth,
2006             MIN_NTLM_AUTH_MAJOR_VERSION,
2007             MIN_NTLM_AUTH_MINOR_VERSION,
2008             MIN_NTLM_AUTH_MICRO_VERSION);
2009         ERR("Usually, you can find it in the winbind package of your "
2010             "distribution.\n");
2011
2012     }
2013     cleanup_helper(helper);
2014 }