dlls/secur32/secur32.c

   1 /* Copyright (C) 2004 Juan Lang
   2  *
   3  * This file implements loading of SSP DLLs.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19 #include <assert.h>
  20 #include <stdarg.h>
  21
  22 #include "ntstatus.h"
  23 #define WIN32_NO_STATUS
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winnls.h"
  27 #include "winreg.h"
  28 #include "winternl.h"
  29 #include "shlwapi.h"
  30 #include "sspi.h"
  31 #include "secur32_priv.h"
  32 #include "secext.h"
  33 #include "ntsecapi.h"
  34 #include "thunks.h"
  35 #include "lmcons.h"
  36
  37 #include "wine/list.h"
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(secur32);
  41
  42 /**
  43  *  Type definitions
  44  */
  45
  46 typedef struct _SecurePackageTable
  47 {
  48     DWORD numPackages;
  49     DWORD numAllocated;
  50     struct list table;
  51 } SecurePackageTable;
  52
  53 typedef struct _SecureProviderTable
  54 {
  55     DWORD numProviders;
  56     DWORD numAllocated;
  57     struct list table;
  58 } SecureProviderTable;
  59
  60 /**
  61  *  Prototypes
  62  */
  63
  64 /* Tries to load moduleName as a provider.  If successful, enumerates what
  65  * packages it can and adds them to the package and provider tables.  Resizes
  66  * tables as necessary.
  67  */
  68 static void _tryLoadProvider(PWSTR moduleName);
  69
  70 /* Initialization: read securityproviders value and attempt to open each dll
  71  * there.  For each DLL, call _tryLoadProvider to see if it's really an SSP.
  72  * Two undocumented functions, AddSecurityPackage(A/W) and
  73  * DeleteSecurityPackage(A/W), seem suspiciously like they'd register or
  74  * unregister a dll, but I'm not sure.
  75  */
  76 static void SECUR32_initializeProviders(void);
  77
  78 /* Frees all loaded packages and providers */
  79 static void SECUR32_freeProviders(void);
  80
  81 /**
  82  *  Globals
  83  */
  84
  85 static CRITICAL_SECTION cs;
  86 static SecurePackageTable *packageTable = NULL;
  87 static SecureProviderTable *providerTable = NULL;
  88
  89 static SecurityFunctionTableA securityFunctionTableA = {
  90     SECURITY_SUPPORT_PROVIDER_INTERFACE_VERSION,
  91     EnumerateSecurityPackagesA,
  92     QueryCredentialsAttributesA,
  93     AcquireCredentialsHandleA,
  94     FreeCredentialsHandle,
  95     NULL, /* Reserved2 */
  96     InitializeSecurityContextA,
  97     AcceptSecurityContext,
  98     CompleteAuthToken,
  99     DeleteSecurityContext,
 100     ApplyControlToken,
 101     QueryContextAttributesA,
 102     ImpersonateSecurityContext,
 103     RevertSecurityContext,
 104     MakeSignature,
 105     VerifySignature,
 106     FreeContextBuffer,
 107     QuerySecurityPackageInfoA,
 108     EncryptMessage, /* Reserved3 */
 109     DecryptMessage, /* Reserved4 */
 110     ExportSecurityContext,
 111     ImportSecurityContextA,
 112     AddCredentialsA,
 113     NULL, /* Reserved8 */
 114     QuerySecurityContextToken,
 115     EncryptMessage,
 116     DecryptMessage,
 117     SetContextAttributesA
 118 };
 119
 120 static SecurityFunctionTableW securityFunctionTableW = {
 121     SECURITY_SUPPORT_PROVIDER_INTERFACE_VERSION,
 122     EnumerateSecurityPackagesW,
 123     QueryCredentialsAttributesW,
 124     AcquireCredentialsHandleW,
 125     FreeCredentialsHandle,
 126     NULL, /* Reserved2 */
 127     InitializeSecurityContextW,
 128     AcceptSecurityContext,
 129     CompleteAuthToken,
 130     DeleteSecurityContext,
 131     ApplyControlToken,
 132     QueryContextAttributesW,
 133     ImpersonateSecurityContext,
 134     RevertSecurityContext,
 135     MakeSignature,
 136     VerifySignature,
 137     FreeContextBuffer,
 138     QuerySecurityPackageInfoW,
 139     EncryptMessage, /* Reserved3 */
 140     DecryptMessage, /* Reserved4 */
 141     ExportSecurityContext,
 142     ImportSecurityContextW,
 143     AddCredentialsW,
 144     NULL, /* Reserved8 */
 145     QuerySecurityContextToken,
 146     EncryptMessage,
 147     DecryptMessage,
 148     SetContextAttributesW
 149 };
 150
 151 /***********************************************************************
 152  *              InitSecurityInterfaceA (SECUR32.@)
 153  */
 154 PSecurityFunctionTableA WINAPI InitSecurityInterfaceA(void)
 155 {
 156     return &securityFunctionTableA;
 157 }
 158
 159 /***********************************************************************
 160  *              InitSecurityInterfaceW (SECUR32.@)
 161  */
 162 PSecurityFunctionTableW WINAPI InitSecurityInterfaceW(void)
 163 {
 164     return &securityFunctionTableW;
 165 }
 166
 167 static PWSTR SECUR32_strdupW(PCWSTR str)
 168 {
 169     PWSTR ret;
 170
 171     if (str)
 172     {
 173         ret = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(str) + 1) * sizeof(WCHAR));
 174         if (ret)
 175             lstrcpyW(ret, str);
 176     }
 177     else
 178         ret = NULL;
 179     return ret;
 180 }
 181
 182 PWSTR SECUR32_AllocWideFromMultiByte(PCSTR str)
 183 {
 184     PWSTR ret;
 185
 186     if (str)
 187     {
 188         int charsNeeded = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
 189
 190         if (charsNeeded)
 191         {
 192             ret = HeapAlloc(GetProcessHeap(), 0, charsNeeded * sizeof(WCHAR));
 193             if (ret)
 194                 MultiByteToWideChar(CP_ACP, 0, str, -1, ret, charsNeeded);
 195         }
 196         else
 197             ret = NULL;
 198     }
 199     else
 200         ret = NULL;
 201     return ret;
 202 }
 203
 204 PSTR SECUR32_AllocMultiByteFromWide(PCWSTR str)
 205 {
 206     PSTR ret;
 207
 208     if (str)
 209     {
 210         int charsNeeded = WideCharToMultiByte(CP_ACP, 0, str, -1, NULL, 0,
 211          NULL, NULL);
 212
 213         if (charsNeeded)
 214         {
 215             ret = HeapAlloc(GetProcessHeap(), 0, charsNeeded);
 216             if (ret)
 217                 WideCharToMultiByte(CP_ACP, 0, str, -1, ret, charsNeeded,
 218                  NULL, NULL);
 219         }
 220         else
 221             ret = NULL;
 222     }
 223     else
 224         ret = NULL;
 225     return ret;
 226 }
 227
 228 static void _makeFnTableA(PSecurityFunctionTableA fnTableA,
 229  const SecurityFunctionTableA *inFnTableA,
 230  const SecurityFunctionTableW *inFnTableW)
 231 {
 232     if (fnTableA)
 233     {
 234         if (inFnTableA)
 235         {
 236             /* The size of the version 1 table is based on platform sdk's
 237              * sspi.h, though the sample ssp also provided with platform sdk
 238              * implies only functions through QuerySecurityPackageInfoA are
 239              * implemented (yikes)
 240              */
 241             size_t tableSize = inFnTableA->dwVersion == 1 ?
 242              (const BYTE *)&inFnTableA->SetContextAttributesA -
 243              (const BYTE *)inFnTableA : sizeof(SecurityFunctionTableA);
 244
 245             memcpy(fnTableA, inFnTableA, tableSize);
 246             /* override this, since we can do it internally anyway */
 247             fnTableA->QuerySecurityPackageInfoA =
 248              QuerySecurityPackageInfoA;
 249         }
 250         else if (inFnTableW)
 251         {
 252             /* functions with thunks */
 253             if (inFnTableW->AcquireCredentialsHandleW)
 254                 fnTableA->AcquireCredentialsHandleA =
 255                  thunk_AcquireCredentialsHandleA;
 256             if (inFnTableW->InitializeSecurityContextW)
 257                 fnTableA->InitializeSecurityContextA =
 258                  thunk_InitializeSecurityContextA;
 259             if (inFnTableW->ImportSecurityContextW)
 260                 fnTableA->ImportSecurityContextA =
 261                  thunk_ImportSecurityContextA;
 262             if (inFnTableW->AddCredentialsW)
 263                 fnTableA->AddCredentialsA =
 264                  thunk_AddCredentialsA;
 265             if (inFnTableW->QueryCredentialsAttributesW)
 266                 fnTableA->QueryCredentialsAttributesA =
 267                  thunk_QueryCredentialsAttributesA;
 268             if (inFnTableW->QueryContextAttributesW)
 269                 fnTableA->QueryContextAttributesA =
 270                  thunk_QueryContextAttributesA;
 271             if (inFnTableW->SetContextAttributesW)
 272                 fnTableA->SetContextAttributesA =
 273                  thunk_SetContextAttributesA;
 274             /* this can't be thunked, there's no extra param to know which
 275              * package to forward to */
 276             fnTableA->EnumerateSecurityPackagesA = NULL;
 277             /* functions with no thunks needed */
 278             fnTableA->AcceptSecurityContext = inFnTableW->AcceptSecurityContext;
 279             fnTableA->CompleteAuthToken = inFnTableW->CompleteAuthToken;
 280             fnTableA->DeleteSecurityContext = inFnTableW->DeleteSecurityContext;
 281             fnTableA->ImpersonateSecurityContext =
 282              inFnTableW->ImpersonateSecurityContext;
 283             fnTableA->RevertSecurityContext = inFnTableW->RevertSecurityContext;
 284             fnTableA->MakeSignature = inFnTableW->MakeSignature;
 285             fnTableA->VerifySignature = inFnTableW->VerifySignature;
 286             fnTableA->FreeContextBuffer = inFnTableW->FreeContextBuffer;
 287             fnTableA->QuerySecurityPackageInfoA =
 288              QuerySecurityPackageInfoA;
 289             fnTableA->ExportSecurityContext =
 290              inFnTableW->ExportSecurityContext;
 291             fnTableA->QuerySecurityContextToken =
 292              inFnTableW->QuerySecurityContextToken;
 293             fnTableA->EncryptMessage = inFnTableW->EncryptMessage;
 294             fnTableA->DecryptMessage = inFnTableW->DecryptMessage;
 295         }
 296     }
 297 }
 298
 299 static void _makeFnTableW(PSecurityFunctionTableW fnTableW,
 300  const SecurityFunctionTableA *inFnTableA,
 301  const SecurityFunctionTableW *inFnTableW)
 302 {
 303     if (fnTableW)
 304     {
 305         if (inFnTableW)
 306         {
 307             /* The size of the version 1 table is based on platform sdk's
 308              * sspi.h, though the sample ssp also provided with platform sdk
 309              * implies only functions through QuerySecurityPackageInfoA are
 310              * implemented (yikes)
 311              */
 312             size_t tableSize = inFnTableW->dwVersion == 1 ?
 313              (const BYTE *)&inFnTableW->SetContextAttributesW -
 314              (const BYTE *)inFnTableW : sizeof(SecurityFunctionTableW);
 315
 316             memcpy(fnTableW, inFnTableW, tableSize);
 317             /* override this, since we can do it internally anyway */
 318             fnTableW->QuerySecurityPackageInfoW =
 319              QuerySecurityPackageInfoW;
 320         }
 321         else if (inFnTableA)
 322         {
 323             /* functions with thunks */
 324             if (inFnTableA->AcquireCredentialsHandleA)
 325                 fnTableW->AcquireCredentialsHandleW =
 326                  thunk_AcquireCredentialsHandleW;
 327             if (inFnTableA->InitializeSecurityContextA)
 328                 fnTableW->InitializeSecurityContextW =
 329                  thunk_InitializeSecurityContextW;
 330             if (inFnTableA->ImportSecurityContextA)
 331                 fnTableW->ImportSecurityContextW =
 332                  thunk_ImportSecurityContextW;
 333             if (inFnTableA->AddCredentialsA)
 334                 fnTableW->AddCredentialsW =
 335                  thunk_AddCredentialsW;
 336             if (inFnTableA->QueryCredentialsAttributesA)
 337                 fnTableW->QueryCredentialsAttributesW =
 338                  thunk_QueryCredentialsAttributesW;
 339             if (inFnTableA->QueryContextAttributesA)
 340                 fnTableW->QueryContextAttributesW =
 341                  thunk_QueryContextAttributesW;
 342             if (inFnTableA->SetContextAttributesA)
 343                 fnTableW->SetContextAttributesW =
 344                  thunk_SetContextAttributesW;
 345             /* this can't be thunked, there's no extra param to know which
 346              * package to forward to */
 347             fnTableW->EnumerateSecurityPackagesW = NULL;
 348             /* functions with no thunks needed */
 349             fnTableW->AcceptSecurityContext = inFnTableA->AcceptSecurityContext;
 350             fnTableW->CompleteAuthToken = inFnTableA->CompleteAuthToken;
 351             fnTableW->DeleteSecurityContext = inFnTableA->DeleteSecurityContext;
 352             fnTableW->ImpersonateSecurityContext =
 353              inFnTableA->ImpersonateSecurityContext;
 354             fnTableW->RevertSecurityContext = inFnTableA->RevertSecurityContext;
 355             fnTableW->MakeSignature = inFnTableA->MakeSignature;
 356             fnTableW->VerifySignature = inFnTableA->VerifySignature;
 357             fnTableW->FreeContextBuffer = inFnTableA->FreeContextBuffer;
 358             fnTableW->QuerySecurityPackageInfoW =
 359              QuerySecurityPackageInfoW;
 360             fnTableW->ExportSecurityContext =
 361              inFnTableA->ExportSecurityContext;
 362             fnTableW->QuerySecurityContextToken =
 363              inFnTableA->QuerySecurityContextToken;
 364             fnTableW->EncryptMessage = inFnTableA->EncryptMessage;
 365             fnTableW->DecryptMessage = inFnTableA->DecryptMessage;
 366         }
 367     }
 368 }
 369
 370 static void _copyPackageInfo(PSecPkgInfoW info, const SecPkgInfoA *inInfoA,
 371  const SecPkgInfoW *inInfoW)
 372 {
 373     if (info && (inInfoA || inInfoW))
 374     {
 375         /* odd, I know, but up until Name and Comment the structures are
 376          * identical
 377          */
 378         memcpy(info, inInfoW ? inInfoW : (const SecPkgInfoW *)inInfoA, sizeof(*info));
 379         if (inInfoW)
 380         {
 381             info->Name = SECUR32_strdupW(inInfoW->Name);
 382             info->Comment = SECUR32_strdupW(inInfoW->Comment);
 383         }
 384         else
 385         {
 386             info->Name = SECUR32_AllocWideFromMultiByte(inInfoA->Name);
 387             info->Comment = SECUR32_AllocWideFromMultiByte(inInfoA->Comment);
 388         }
 389     }
 390 }
 391
 392 SecureProvider *SECUR32_addProvider(const SecurityFunctionTableA *fnTableA,
 393  const SecurityFunctionTableW *fnTableW, PCWSTR moduleName)
 394 {
 395     SecureProvider *ret;
 396
 397     EnterCriticalSection(&cs);
 398
 399     if (!providerTable)
 400     {
 401         providerTable = HeapAlloc(GetProcessHeap(), 0, sizeof(SecureProviderTable));
 402         if (!providerTable)
 403         {
 404             LeaveCriticalSection(&cs);
 405             return NULL;
 406         }
 407
 408         list_init(&providerTable->table);
 409     }
 410
 411     ret = HeapAlloc(GetProcessHeap(), 0, sizeof(SecureProvider));
 412     if (!ret)
 413     {
 414         LeaveCriticalSection(&cs);
 415         return NULL;
 416     }
 417
 418     list_add_tail(&providerTable->table, &ret->entry);
 419     ret->lib = NULL;
 420
 421     if (fnTableA || fnTableW)
 422     {
 423         ret->moduleName = moduleName ? SECUR32_strdupW(moduleName) : NULL;
 424         _makeFnTableA(&ret->fnTableA, fnTableA, fnTableW);
 425         _makeFnTableW(&ret->fnTableW, fnTableA, fnTableW);
 426         ret->loaded = moduleName ? FALSE : TRUE;
 427     }
 428     else
 429     {
 430         ret->moduleName = SECUR32_strdupW(moduleName);
 431         ret->loaded = FALSE;
 432     }
 433
 434     LeaveCriticalSection(&cs);
 435     return ret;
 436 }
 437
 438 void SECUR32_addPackages(SecureProvider *provider, ULONG toAdd,
 439  const SecPkgInfoA *infoA, const SecPkgInfoW *infoW)
 440 {
 441     ULONG i;
 442
 443     assert(provider);
 444     assert(infoA || infoW);
 445
 446     EnterCriticalSection(&cs);
 447
 448     if (!packageTable)
 449     {
 450         packageTable = HeapAlloc(GetProcessHeap(), 0, sizeof(SecurePackageTable));
 451         if (!packageTable)
 452         {
 453             LeaveCriticalSection(&cs);
 454             return;
 455         }
 456
 457         packageTable->numPackages = 0;
 458         list_init(&packageTable->table);
 459     }
 460
 461     for (i = 0; i < toAdd; i++)
 462     {
 463         SecurePackage *package = HeapAlloc(GetProcessHeap(), 0, sizeof(SecurePackage));
 464         if (!package)
 465             continue;
 466
 467         list_add_tail(&packageTable->table, &package->entry);
 468
 469         package->provider = provider;
 470         _copyPackageInfo(&package->infoW,
 471             infoA ? &infoA[i] : NULL,
 472             infoW ? &infoW[i] : NULL);
 473     }
 474     packageTable->numPackages += toAdd;
 475
 476     LeaveCriticalSection(&cs);
 477 }
 478
 479 static void _tryLoadProvider(PWSTR moduleName)
 480 {
 481     HMODULE lib = LoadLibraryW(moduleName);
 482
 483     if (lib)
 484     {
 485         INIT_SECURITY_INTERFACE_W pInitSecurityInterfaceW =
 486          (INIT_SECURITY_INTERFACE_W)GetProcAddress(lib,
 487          SECURITY_ENTRYPOINT_ANSIW);
 488         INIT_SECURITY_INTERFACE_A pInitSecurityInterfaceA =
 489          (INIT_SECURITY_INTERFACE_A)GetProcAddress(lib,
 490          SECURITY_ENTRYPOINT_ANSIA);
 491
 492         TRACE("loaded %s, InitSecurityInterfaceA is %p, InitSecurityInterfaceW is %p\n",
 493          debugstr_w(moduleName), pInitSecurityInterfaceA,
 494          pInitSecurityInterfaceW);
 495         if (pInitSecurityInterfaceW || pInitSecurityInterfaceA)
 496         {
 497             PSecurityFunctionTableA fnTableA = NULL;
 498             PSecurityFunctionTableW fnTableW = NULL;
 499             ULONG toAdd = 0;
 500             PSecPkgInfoA infoA = NULL;
 501             PSecPkgInfoW infoW = NULL;
 502             SECURITY_STATUS ret = SEC_E_OK;
 503
 504             if (pInitSecurityInterfaceA)
 505                 fnTableA = pInitSecurityInterfaceA();
 506             if (pInitSecurityInterfaceW)
 507                 fnTableW = pInitSecurityInterfaceW();
 508             if (fnTableW && fnTableW->EnumerateSecurityPackagesW)
 509             {
 510                 if (fnTableW != &securityFunctionTableW)
 511                     ret = fnTableW->EnumerateSecurityPackagesW(&toAdd, &infoW);
 512                 else
 513                     TRACE("%s has built-in providers, skip adding\n", debugstr_w(moduleName));
 514             }
 515             else if (fnTableA && fnTableA->EnumerateSecurityPackagesA)
 516             {
 517                 if (fnTableA != &securityFunctionTableA)
 518                     ret = fnTableA->EnumerateSecurityPackagesA(&toAdd, &infoA);
 519                 else
 520                     TRACE("%s has built-in providers, skip adding\n", debugstr_w(moduleName));
 521             }
 522             if (ret == SEC_E_OK && toAdd > 0 && (infoW || infoA))
 523             {
 524                 SecureProvider *provider = SECUR32_addProvider(NULL, NULL,
 525                  moduleName);
 526
 527                 if (provider)
 528                     SECUR32_addPackages(provider, toAdd, infoA, infoW);
 529                 if (infoW)
 530                     fnTableW->FreeContextBuffer(infoW);
 531                 else
 532                     fnTableA->FreeContextBuffer(infoA);
 533             }
 534         }
 535         FreeLibrary(lib);
 536     }
 537     else
 538         WARN("failed to load %s\n", debugstr_w(moduleName));
 539 }
 540
 541 static const WCHAR securityProvidersKeyW[] = {
 542  'S','Y','S','T','E','M','\\','C','u','r','r','e','n','t','C','o','n','t','r',
 543  'o','l','S','e','t','\\','C','o','n','t','r','o','l','\\','S','e','c','u','r',
 544  'i','t','y','P','r','o','v','i','d','e','r','s','\0'
 545  };
 546 static const WCHAR securityProvidersW[] = {
 547  'S','e','c','u','r','i','t','y','P','r','o','v','i','d','e','r','s',0
 548  };
 549
 550 static void SECUR32_initializeProviders(void)
 551 {
 552     HKEY key;
 553     LSTATUS apiRet;
 554
 555     TRACE("\n");
 556     InitializeCriticalSection(&cs);
 557     cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": cs");
 558     /* First load built-in providers */
 559     SECUR32_initSchannelSP();
 560     SECUR32_initNTLMSP();
 561     /* Load the Negotiate provider last so apps stumble over the working NTLM
 562      * provider first. Attempting to fix bug #16905 while keeping the
 563      * application reported on wine-users on 2006-09-12 working. */
 564     SECUR32_initNegotiateSP();
 565     /* Now load providers from registry */
 566     apiRet = RegOpenKeyExW(HKEY_LOCAL_MACHINE, securityProvidersKeyW, 0,
 567      KEY_READ, &key);
 568     if (apiRet == ERROR_SUCCESS)
 569     {
 570         WCHAR securityPkgNames[MAX_PATH]; /* arbitrary len */
 571         DWORD size = sizeof(securityPkgNames) / sizeof(WCHAR), type;
 572
 573         apiRet = RegQueryValueExW(key, securityProvidersW, NULL, &type,
 574          (PBYTE)securityPkgNames, &size);
 575         if (apiRet == ERROR_SUCCESS && type == REG_SZ)
 576         {
 577             WCHAR *ptr;
 578
 579             size = size / sizeof(WCHAR);
 580             for (ptr = securityPkgNames;
 581               ptr < securityPkgNames + size; )
 582             {
 583                 WCHAR *comma;
 584
 585                 for (comma = ptr; *comma && *comma != ','; comma++)
 586                     ;
 587                 if (*comma == ',')
 588                     *comma = '\0';
 589                 for (; *ptr && isspace(*ptr) && ptr < securityPkgNames + size;
 590                  ptr++)
 591                     ;
 592                 if (*ptr)
 593                     _tryLoadProvider(ptr);
 594                 ptr += lstrlenW(ptr) + 1;
 595             }
 596         }
 597         RegCloseKey(key);
 598     }
 599 }
 600
 601 SecurePackage *SECUR32_findPackageW(PCWSTR packageName)
 602 {
 603     SecurePackage *ret = NULL;
 604     BOOL matched = FALSE;
 605
 606     if (packageTable && packageName)
 607     {
 608         LIST_FOR_EACH_ENTRY(ret, &packageTable->table, SecurePackage, entry)
 609         {
 610             matched = !lstrcmpiW(ret->infoW.Name, packageName);
 611             if (matched)
 612                 break;
 613         }
 614
 615         if (!matched)
 616                 return NULL;
 617
 618         if (ret->provider && !ret->provider->loaded)
 619         {
 620             ret->provider->lib = LoadLibraryW(ret->provider->moduleName);
 621             if (ret->provider->lib)
 622             {
 623                 INIT_SECURITY_INTERFACE_W pInitSecurityInterfaceW =
 624                  (INIT_SECURITY_INTERFACE_W)GetProcAddress(ret->provider->lib,
 625                  SECURITY_ENTRYPOINT_ANSIW);
 626                 INIT_SECURITY_INTERFACE_A pInitSecurityInterfaceA =
 627                  (INIT_SECURITY_INTERFACE_A)GetProcAddress(ret->provider->lib,
 628                  SECURITY_ENTRYPOINT_ANSIA);
 629                 PSecurityFunctionTableA fnTableA = NULL;
 630                 PSecurityFunctionTableW fnTableW = NULL;
 631
 632                 if (pInitSecurityInterfaceA)
 633                     fnTableA = pInitSecurityInterfaceA();
 634                 if (pInitSecurityInterfaceW)
 635                     fnTableW = pInitSecurityInterfaceW();
 636                 /* don't update built-in SecurityFunctionTable */
 637                 if (fnTableA != &securityFunctionTableA)
 638                     _makeFnTableA(&ret->provider->fnTableA, fnTableA, fnTableW);
 639                 if (fnTableW != &securityFunctionTableW)
 640                     _makeFnTableW(&ret->provider->fnTableW, fnTableA, fnTableW);
 641                 ret->provider->loaded = TRUE;
 642             }
 643             else
 644                 ret = NULL;
 645         }
 646     }
 647     return ret;
 648 }
 649
 650 SecurePackage *SECUR32_findPackageA(PCSTR packageName)
 651 {
 652     SecurePackage *ret;
 653
 654     if (packageTable && packageName)
 655     {
 656         UNICODE_STRING package;
 657
 658         RtlCreateUnicodeStringFromAsciiz(&package, packageName);
 659         ret = SECUR32_findPackageW(package.Buffer);
 660         RtlFreeUnicodeString(&package);
 661     }
 662     else
 663         ret = NULL;
 664     return ret;
 665 }
 666
 667 static void SECUR32_freeProviders(void)
 668 {
 669     TRACE("\n");
 670     EnterCriticalSection(&cs);
 671
 672     SECUR32_deinitSchannelSP();
 673
 674     if (packageTable)
 675     {
 676         SecurePackage *package, *package_next;
 677         LIST_FOR_EACH_ENTRY_SAFE(package, package_next, &packageTable->table,
 678                                  SecurePackage, entry)
 679         {
 680             HeapFree(GetProcessHeap(), 0, package->infoW.Name);
 681             HeapFree(GetProcessHeap(), 0, package->infoW.Comment);
 682             HeapFree(GetProcessHeap(), 0, package);
 683         }
 684
 685         HeapFree(GetProcessHeap(), 0, packageTable);
 686         packageTable = NULL;
 687     }
 688
 689     if (providerTable)
 690     {
 691         SecureProvider *provider, *provider_next;
 692         LIST_FOR_EACH_ENTRY_SAFE(provider, provider_next, &providerTable->table,
 693                                  SecureProvider, entry)
 694         {
 695             HeapFree(GetProcessHeap(), 0, provider->moduleName);
 696             if (provider->lib)
 697                 FreeLibrary(provider->lib);
 698             HeapFree(GetProcessHeap(), 0, provider);
 699         }
 700
 701         HeapFree(GetProcessHeap(), 0, providerTable);
 702         providerTable = NULL;
 703     }
 704
 705     LeaveCriticalSection(&cs);
 706     cs.DebugInfo->Spare[0] = 0;
 707     DeleteCriticalSection(&cs);
 708 }
 709
 710 /***********************************************************************
 711  *              FreeContextBuffer (SECUR32.@)
 712  *
 713  * Doh--if pv was allocated by a crypto package, this may not be correct.
 714  * The sample ssp seems to use LocalAlloc/LocalFee, but there doesn't seem to
 715  * be any guarantee, nor is there an alloc function in secur32.
 716  */
 717 SECURITY_STATUS WINAPI FreeContextBuffer(PVOID pv)
 718 {
 719     HeapFree(GetProcessHeap(), 0, pv);
 720
 721     return SEC_E_OK;
 722 }
 723
 724 /***********************************************************************
 725  *              EnumerateSecurityPackagesW (SECUR32.@)
 726  */
 727 SECURITY_STATUS WINAPI EnumerateSecurityPackagesW(PULONG pcPackages,
 728  PSecPkgInfoW *ppPackageInfo)
 729 {
 730     SECURITY_STATUS ret = SEC_E_OK;
 731
 732     TRACE("(%p, %p)\n", pcPackages, ppPackageInfo);
 733
 734     /* windows just crashes if pcPackages or ppPackageInfo is NULL, so will I */
 735     *pcPackages = 0;
 736     EnterCriticalSection(&cs);
 737     if (packageTable)
 738     {
 739         SecurePackage *package;
 740         size_t bytesNeeded;
 741
 742         bytesNeeded = packageTable->numPackages * sizeof(SecPkgInfoW);
 743         LIST_FOR_EACH_ENTRY(package, &packageTable->table, SecurePackage, entry)
 744         {
 745             if (package->infoW.Name)
 746                 bytesNeeded += (lstrlenW(package->infoW.Name) + 1) * sizeof(WCHAR);
 747             if (package->infoW.Comment)
 748                 bytesNeeded += (lstrlenW(package->infoW.Comment) + 1) * sizeof(WCHAR);
 749         }
 750         if (bytesNeeded)
 751         {
 752             *ppPackageInfo = HeapAlloc(GetProcessHeap(), 0, bytesNeeded);
 753             if (*ppPackageInfo)
 754             {
 755                 ULONG i = 0;
 756                 PWSTR nextString;
 757
 758                 *pcPackages = packageTable->numPackages;
 759                 nextString = (PWSTR)((PBYTE)*ppPackageInfo +
 760                  packageTable->numPackages * sizeof(SecPkgInfoW));
 761                 LIST_FOR_EACH_ENTRY(package, &packageTable->table, SecurePackage, entry)
 762                 {
 763                     PSecPkgInfoW pkgInfo = *ppPackageInfo + i++;
 764
 765                     *pkgInfo = package->infoW;
 766                     if (package->infoW.Name)
 767                     {
 768                         TRACE("Name[%d] = %s\n", i - 1, debugstr_w(package->infoW.Name));
 769                         pkgInfo->Name = nextString;
 770                         lstrcpyW(nextString, package->infoW.Name);
 771                         nextString += lstrlenW(nextString) + 1;
 772                     }
 773                     else
 774                         pkgInfo->Name = NULL;
 775                     if (package->infoW.Comment)
 776                     {
 777                         TRACE("Comment[%d] = %s\n", i - 1, debugstr_w(package->infoW.Comment));
 778                         pkgInfo->Comment = nextString;
 779                         lstrcpyW(nextString, package->infoW.Comment);
 780                         nextString += lstrlenW(nextString) + 1;
 781                     }
 782                     else
 783                         pkgInfo->Comment = NULL;
 784                 }
 785             }
 786             else
 787                 ret = SEC_E_INSUFFICIENT_MEMORY;
 788         }
 789     }
 790     LeaveCriticalSection(&cs);
 791     TRACE("<-- 0x%08x\n", ret);
 792     return ret;
 793 }
 794
 795 /* Converts info (which is assumed to be an array of cPackages SecPkgInfoW
 796  * structures) into an array of SecPkgInfoA structures, which it returns.
 797  */
 798 static PSecPkgInfoA thunk_PSecPkgInfoWToA(ULONG cPackages,
 799  const SecPkgInfoW *info)
 800 {
 801     PSecPkgInfoA ret;
 802
 803     if (info)
 804     {
 805         size_t bytesNeeded = cPackages * sizeof(SecPkgInfoA);
 806         ULONG i;
 807
 808         for (i = 0; i < cPackages; i++)
 809         {
 810             if (info[i].Name)
 811                 bytesNeeded += WideCharToMultiByte(CP_ACP, 0, info[i].Name,
 812                  -1, NULL, 0, NULL, NULL);
 813             if (info[i].Comment)
 814                 bytesNeeded += WideCharToMultiByte(CP_ACP, 0, info[i].Comment,
 815                  -1, NULL, 0, NULL, NULL);
 816         }
 817         ret = HeapAlloc(GetProcessHeap(), 0, bytesNeeded);
 818         if (ret)
 819         {
 820             PSTR nextString;
 821
 822             nextString = (PSTR)((PBYTE)ret + cPackages * sizeof(SecPkgInfoA));
 823             for (i = 0; i < cPackages; i++)
 824             {
 825                 PSecPkgInfoA pkgInfo = ret + i;
 826                 int bytes;
 827
 828                 memcpy(pkgInfo, &info[i], sizeof(SecPkgInfoA));
 829                 if (info[i].Name)
 830                 {
 831                     pkgInfo->Name = nextString;
 832                     /* just repeat back to WideCharToMultiByte how many bytes
 833                      * it requires, since we asked it earlier
 834                      */
 835                     bytes = WideCharToMultiByte(CP_ACP, 0, info[i].Name, -1,
 836                      NULL, 0, NULL, NULL);
 837                     WideCharToMultiByte(CP_ACP, 0, info[i].Name, -1,
 838                      pkgInfo->Name, bytes, NULL, NULL);
 839                     nextString += lstrlenA(nextString) + 1;
 840                 }
 841                 else
 842                     pkgInfo->Name = NULL;
 843                 if (info[i].Comment)
 844                 {
 845                     pkgInfo->Comment = nextString;
 846                     /* just repeat back to WideCharToMultiByte how many bytes
 847                      * it requires, since we asked it earlier
 848                      */
 849                     bytes = WideCharToMultiByte(CP_ACP, 0, info[i].Comment, -1,
 850                      NULL, 0, NULL, NULL);
 851                     WideCharToMultiByte(CP_ACP, 0, info[i].Comment, -1,
 852                      pkgInfo->Comment, bytes, NULL, NULL);
 853                     nextString += lstrlenA(nextString) + 1;
 854                 }
 855                 else
 856                     pkgInfo->Comment = NULL;
 857             }
 858         }
 859     }
 860     else
 861         ret = NULL;
 862     return ret;
 863 }
 864
 865 /***********************************************************************
 866  *              EnumerateSecurityPackagesA (SECUR32.@)
 867  */
 868 SECURITY_STATUS WINAPI EnumerateSecurityPackagesA(PULONG pcPackages,
 869  PSecPkgInfoA *ppPackageInfo)
 870 {
 871     SECURITY_STATUS ret;
 872     PSecPkgInfoW info;
 873
 874     ret = EnumerateSecurityPackagesW(pcPackages, &info);
 875     if (ret == SEC_E_OK && *pcPackages && info)
 876     {
 877         *ppPackageInfo = thunk_PSecPkgInfoWToA(*pcPackages, info);
 878         if (*pcPackages && !*ppPackageInfo)
 879         {
 880             *pcPackages = 0;
 881             ret = SEC_E_INSUFFICIENT_MEMORY;
 882         }
 883         FreeContextBuffer(info);
 884     }
 885     return ret;
 886 }
 887
 888 /***********************************************************************
 889  *              GetComputerObjectNameA (SECUR32.@)
 890  *
 891  * Get the local computer's name using the format specified.
 892  *
 893  * PARAMS
 894  *  NameFormat   [I] The format for the name.
 895  *  lpNameBuffer [O] Pointer to buffer to receive the name.
 896  *  nSize        [I/O] Size in characters of buffer.
 897  *
 898  * RETURNS
 899  *  TRUE  If the name was written to lpNameBuffer.
 900  *  FALSE If the name couldn't be written.
 901  *
 902  * NOTES
 903  *  If lpNameBuffer is NULL, then the size of the buffer needed to hold the
 904  *  name will be returned in *nSize.
 905  *
 906  *  nSize returns the number of characters written when lpNameBuffer is not
 907  *  NULL or the size of the buffer needed to hold the name when the buffer
 908  *  is too short or lpNameBuffer is NULL.
 909  *
 910  *  It the buffer is too short, ERROR_INSUFFICIENT_BUFFER error will be set.
 911  */
 912 BOOLEAN WINAPI GetComputerObjectNameA(
 913   EXTENDED_NAME_FORMAT NameFormat, LPSTR lpNameBuffer, PULONG nSize)
 914 {
 915     BOOLEAN rc;
 916     LPWSTR bufferW = NULL;
 917     ULONG sizeW = *nSize;
 918     TRACE("(%d %p %p)\n", NameFormat, lpNameBuffer, nSize);
 919     if (lpNameBuffer) {
 920         bufferW = HeapAlloc(GetProcessHeap(), 0, sizeW * sizeof(WCHAR));
 921         if (bufferW == NULL) {
 922             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 923             return FALSE;
 924         }
 925     }
 926     rc = GetComputerObjectNameW(NameFormat, bufferW, &sizeW);
 927     if (rc && bufferW) {
 928         ULONG len = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL);
 929         WideCharToMultiByte(CP_ACP, 0, bufferW, -1, lpNameBuffer, *nSize, NULL, NULL);
 930         *nSize = len;
 931     }
 932     else
 933         *nSize = sizeW;
 934     HeapFree(GetProcessHeap(), 0, bufferW);
 935     return rc;
 936 }
 937
 938 /***********************************************************************
 939  *              GetComputerObjectNameW (SECUR32.@)
 940  */
 941 BOOLEAN WINAPI GetComputerObjectNameW(
 942   EXTENDED_NAME_FORMAT NameFormat, LPWSTR lpNameBuffer, PULONG nSize)
 943 {
 944     LSA_HANDLE policyHandle;
 945     LSA_OBJECT_ATTRIBUTES objectAttributes;
 946     PPOLICY_DNS_DOMAIN_INFO domainInfo;
 947     NTSTATUS ntStatus;
 948     BOOLEAN status;
 949     TRACE("(%d %p %p)\n", NameFormat, lpNameBuffer, nSize);
 950
 951     if (NameFormat == NameUnknown)
 952     {
 953         SetLastError(ERROR_INVALID_PARAMETER);
 954         return FALSE;
 955     }
 956
 957     ZeroMemory(&objectAttributes, sizeof(objectAttributes));
 958     objectAttributes.Length = sizeof(objectAttributes);
 959
 960     ntStatus = LsaOpenPolicy(NULL, &objectAttributes,
 961                              POLICY_VIEW_LOCAL_INFORMATION,
 962                              &policyHandle);
 963     if (ntStatus != STATUS_SUCCESS)
 964     {
 965         SetLastError(LsaNtStatusToWinError(ntStatus));
 966         WARN("LsaOpenPolicy failed with NT status %u\n", GetLastError());
 967         return FALSE;
 968     }
 969
 970     ntStatus = LsaQueryInformationPolicy(policyHandle,
 971                                          PolicyDnsDomainInformation,
 972                                          (PVOID *)&domainInfo);
 973     if (ntStatus != STATUS_SUCCESS)
 974     {
 975         SetLastError(LsaNtStatusToWinError(ntStatus));
 976         WARN("LsaQueryInformationPolicy failed with NT status %u\n",
 977              GetLastError());
 978         LsaClose(policyHandle);
 979         return FALSE;
 980     }
 981
 982     if (domainInfo->Sid)
 983     {
 984         switch (NameFormat)
 985         {
 986         case NameSamCompatible:
 987             {
 988                 WCHAR name[MAX_COMPUTERNAME_LENGTH + 1];
 989                 DWORD size = sizeof(name)/sizeof(name[0]);
 990                 if (GetComputerNameW(name, &size))
 991                 {
 992                     DWORD len = domainInfo->Name.Length + size + 3;
 993                     if (lpNameBuffer)
 994                     {
 995                         if (*nSize < len)
 996                         {
 997                             *nSize = len;
 998                             SetLastError(ERROR_INSUFFICIENT_BUFFER);
 999                             status = FALSE;
1000                         }
1001                         else
1002                         {
1003                             WCHAR bs[] = { '\\', 0 };
1004                             WCHAR ds[] = { '$', 0 };
1005                             lstrcpyW(lpNameBuffer, domainInfo->Name.Buffer);
1006                             lstrcatW(lpNameBuffer, bs);
1007                             lstrcatW(lpNameBuffer, name);
1008                             lstrcatW(lpNameBuffer, ds);
1009                             status = TRUE;
1010                         }
1011                     }
1012                     else        /* just requesting length required */
1013                     {
1014                         *nSize = len;
1015                         status = TRUE;
1016                     }
1017                 }
1018                 else
1019                 {
1020                     SetLastError(ERROR_INTERNAL_ERROR);
1021                     status = FALSE;
1022                 }
1023             }
1024             break;
1025         case NameFullyQualifiedDN:
1026         case NameDisplay:
1027         case NameUniqueId:
1028         case NameCanonical:
1029         case NameUserPrincipal:
1030         case NameCanonicalEx:
1031         case NameServicePrincipal:
1032         case NameDnsDomain:
1033             FIXME("NameFormat %d not implemented\n", NameFormat);
1034             SetLastError(ERROR_CANT_ACCESS_DOMAIN_INFO);
1035             status = FALSE;
1036             break;
1037         default:
1038             SetLastError(ERROR_INVALID_PARAMETER);
1039             status = FALSE;
1040         }
1041     }
1042     else
1043     {
1044         SetLastError(ERROR_CANT_ACCESS_DOMAIN_INFO);
1045         status = FALSE;
1046     }
1047
1048     LsaFreeMemory(domainInfo);
1049     LsaClose(policyHandle);
1050
1051     return status;
1052 }
1053
1054 /***********************************************************************
1055  *              GetUserNameExA (SECUR32.@)
1056  */
1057 BOOLEAN WINAPI GetUserNameExA(
1058   EXTENDED_NAME_FORMAT NameFormat, LPSTR lpNameBuffer, PULONG nSize)
1059 {
1060     BOOLEAN rc;
1061     LPWSTR bufferW = NULL;
1062     ULONG sizeW = *nSize;
1063     TRACE("(%d %p %p)\n", NameFormat, lpNameBuffer, nSize);
1064     if (lpNameBuffer) {
1065         bufferW = HeapAlloc(GetProcessHeap(), 0, sizeW * sizeof(WCHAR));
1066         if (bufferW == NULL) {
1067             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1068             return FALSE;
1069         }
1070     }
1071     rc = GetUserNameExW(NameFormat, bufferW, &sizeW);
1072     if (rc) {
1073         ULONG len = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL);
1074         if (len <= *nSize)
1075         {
1076             WideCharToMultiByte(CP_ACP, 0, bufferW, -1, lpNameBuffer, *nSize, NULL, NULL);
1077             *nSize = len - 1;
1078         }
1079         else
1080         {
1081             *nSize = len;
1082             rc = FALSE;
1083             SetLastError(ERROR_MORE_DATA);
1084         }
1085     }
1086     else
1087         *nSize = sizeW;
1088     HeapFree(GetProcessHeap(), 0, bufferW);
1089     return rc;
1090 }
1091
1092 BOOLEAN WINAPI GetUserNameExW(
1093   EXTENDED_NAME_FORMAT NameFormat, LPWSTR lpNameBuffer, PULONG nSize)
1094 {
1095     BOOLEAN status;
1096     WCHAR samname[UNLEN + 1 + MAX_COMPUTERNAME_LENGTH + 1];
1097     LPWSTR out;
1098     DWORD len;
1099     TRACE("(%d %p %p)\n", NameFormat, lpNameBuffer, nSize);
1100
1101     switch (NameFormat)
1102     {
1103     case NameSamCompatible:
1104         {
1105             /* This assumes the current user is always a local account */
1106             len = MAX_COMPUTERNAME_LENGTH + 1;
1107             if (GetComputerNameW(samname, &len))
1108             {
1109                 out = samname + lstrlenW(samname);
1110                 *out++ = '\\';
1111                 len = UNLEN + 1;
1112                 if (GetUserNameW(out, &len))
1113                 {
1114                     status = (lstrlenW(samname) < *nSize);
1115                     if (status)
1116                     {
1117                         lstrcpyW(lpNameBuffer, samname);
1118                         *nSize = lstrlenW(samname);
1119                     }
1120                     else
1121                     {
1122                         SetLastError(ERROR_MORE_DATA);
1123                         *nSize = lstrlenW(samname) + 1;
1124                     }
1125                 }
1126                 else
1127                     status = FALSE;
1128             }
1129             else
1130                 status = FALSE;
1131         }
1132         break;
1133     case NameUnknown:
1134     case NameFullyQualifiedDN:
1135     case NameDisplay:
1136     case NameUniqueId:
1137     case NameCanonical:
1138     case NameUserPrincipal:
1139     case NameCanonicalEx:
1140     case NameServicePrincipal:
1141     case NameDnsDomain:
1142         SetLastError(ERROR_NONE_MAPPED);
1143         status = FALSE;
1144         break;
1145     default:
1146         SetLastError(ERROR_INVALID_PARAMETER);
1147         status = FALSE;
1148     }
1149
1150     return status;
1151 }
1152
1153 BOOLEAN WINAPI TranslateNameA(
1154   LPCSTR lpAccountName, EXTENDED_NAME_FORMAT AccountNameFormat,
1155   EXTENDED_NAME_FORMAT DesiredNameFormat, LPSTR lpTranslatedName,
1156   PULONG nSize)
1157 {
1158     FIXME("%p %d %d %p %p\n", lpAccountName, AccountNameFormat,
1159           DesiredNameFormat, lpTranslatedName, nSize);
1160     return FALSE;
1161 }
1162
1163 BOOLEAN WINAPI TranslateNameW(
1164   LPCWSTR lpAccountName, EXTENDED_NAME_FORMAT AccountNameFormat,
1165   EXTENDED_NAME_FORMAT DesiredNameFormat, LPWSTR lpTranslatedName,
1166   PULONG nSize)
1167 {
1168     FIXME("%p %d %d %p %p\n", lpAccountName, AccountNameFormat,
1169           DesiredNameFormat, lpTranslatedName, nSize);
1170     return FALSE;
1171 }
1172
1173 /***********************************************************************
1174  *              DllMain (SECUR32.0)
1175  */
1176 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
1177 {
1178     if (fdwReason == DLL_PROCESS_ATTACH)
1179     {
1180         DisableThreadLibraryCalls(hinstDLL);
1181         SECUR32_initializeProviders();
1182     }
1183     else if (fdwReason == DLL_PROCESS_DETACH)
1184     {
1185         SECUR32_freeProviders();
1186     }
1187
1188     return TRUE;
1189 }