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

   1 /* Copyright (C) 2004 Juan Lang
   2  *
   3  * Implements secur32 functions that forward to (wrap) an SSP's implementation.
   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 <stdarg.h>
  20 #include "windef.h"
  21 #include "winbase.h"
  22 #include "winnls.h"
  23 #include "sspi.h"
  24 #include "secur32_priv.h"
  25
  26 #include "wine/debug.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(secur32);
  29
  30 /* Tries to allocate a new SecHandle, into which it stores package (in
  31  * phSec->dwUpper) and a copy of realHandle (allocated with SECUR32_ALLOC,
  32  * and stored in phSec->dwLower).  SecHandle is equivalent to both a
  33  * CredHandle and a CtxtHandle.
  34  */
  35 static SECURITY_STATUS SECUR32_makeSecHandle(PSecHandle phSec,
  36  SecurePackage *package, PSecHandle realHandle)
  37 {
  38     SECURITY_STATUS ret;
  39
  40     TRACE("%p %p %p\n", phSec, package, realHandle);
  41
  42     if (phSec && package && realHandle)
  43     {
  44         PSecHandle newSec = HeapAlloc(GetProcessHeap(), 0, sizeof(SecHandle));
  45
  46         if (newSec)
  47         {
  48             *newSec = *realHandle;
  49             phSec->dwUpper = (ULONG_PTR)package;
  50             phSec->dwLower = (ULONG_PTR)newSec;
  51             ret = SEC_E_OK;
  52         }
  53         else
  54             ret = SEC_E_INSUFFICIENT_MEMORY;
  55     }
  56     else
  57         ret = SEC_E_INVALID_HANDLE;
  58     return ret;
  59 }
  60
  61 /***********************************************************************
  62  *              AcquireCredentialsHandleA (SECUR32.@)
  63  */
  64 SECURITY_STATUS WINAPI AcquireCredentialsHandleA(
  65  SEC_CHAR *pszPrincipal, SEC_CHAR *pszPackage, ULONG fCredentialsUse,
  66  PLUID pvLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn,
  67  PVOID pvGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry)
  68 {
  69     SECURITY_STATUS ret;
  70
  71     TRACE("%s %s %d %p %p %p %p %p %p\n", debugstr_a(pszPrincipal),
  72      debugstr_a(pszPackage), fCredentialsUse, pvLogonID, pAuthData, pGetKeyFn,
  73      pvGetKeyArgument, phCredential, ptsExpiry);
  74     if (pszPackage)
  75     {
  76         SecurePackage *package = SECUR32_findPackageA(pszPackage);
  77
  78         if (package && package->provider)
  79         {
  80             if (package->provider->fnTableA.AcquireCredentialsHandleA)
  81             {
  82                 CredHandle myCred;
  83
  84                 ret = package->provider->fnTableA.AcquireCredentialsHandleA(
  85                  pszPrincipal, pszPackage, fCredentialsUse, pvLogonID,
  86                  pAuthData, pGetKeyFn, pvGetKeyArgument, &myCred,
  87                  ptsExpiry);
  88                 if (ret == SEC_E_OK)
  89                 {
  90                     ret = SECUR32_makeSecHandle(phCredential, package, &myCred);
  91                     if (ret != SEC_E_OK)
  92                         package->provider->fnTableW.FreeCredentialsHandle(
  93                          &myCred);
  94                 }
  95             }
  96             else
  97                 ret = SEC_E_UNSUPPORTED_FUNCTION;
  98         }
  99         else
 100             ret = SEC_E_SECPKG_NOT_FOUND;
 101     }
 102     else
 103         ret = SEC_E_SECPKG_NOT_FOUND;
 104     return ret;
 105 }
 106
 107 /***********************************************************************
 108  *              AcquireCredentialsHandleW (SECUR32.@)
 109  */
 110 SECURITY_STATUS WINAPI AcquireCredentialsHandleW(
 111  SEC_WCHAR *pszPrincipal, SEC_WCHAR *pszPackage, ULONG fCredentialsUse,
 112  PLUID pvLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn,
 113  PVOID pvGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry)
 114 {
 115     SECURITY_STATUS ret;
 116
 117     TRACE("%s %s %d %p %p %p %p %p %p\n", debugstr_w(pszPrincipal),
 118      debugstr_w(pszPackage), fCredentialsUse, pvLogonID, pAuthData, pGetKeyFn,
 119      pvGetKeyArgument, phCredential, ptsExpiry);
 120     if (pszPackage)
 121     {
 122         SecurePackage *package = SECUR32_findPackageW(pszPackage);
 123
 124         if (package && package->provider)
 125         {
 126             if (package->provider->fnTableW.AcquireCredentialsHandleW)
 127             {
 128                 CredHandle myCred;
 129
 130                 ret = package->provider->fnTableW.AcquireCredentialsHandleW(
 131                  pszPrincipal, pszPackage, fCredentialsUse, pvLogonID,
 132                  pAuthData, pGetKeyFn, pvGetKeyArgument, &myCred,
 133                  ptsExpiry);
 134                 if (ret == SEC_E_OK)
 135                 {
 136                     ret = SECUR32_makeSecHandle(phCredential, package, &myCred);
 137                     if (ret != SEC_E_OK)
 138                         package->provider->fnTableW.FreeCredentialsHandle(
 139                          &myCred);
 140                 }
 141             }
 142             else
 143                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 144         }
 145         else
 146             ret = SEC_E_SECPKG_NOT_FOUND;
 147     }
 148     else
 149         ret = SEC_E_SECPKG_NOT_FOUND;
 150     return ret;
 151 }
 152
 153 /***********************************************************************
 154  *              FreeCredentialsHandle (SECUR32.@)
 155  */
 156 SECURITY_STATUS WINAPI FreeCredentialsHandle(
 157  PCredHandle phCredential)
 158 {
 159     SECURITY_STATUS ret;
 160
 161     TRACE("%p\n", phCredential);
 162     if (phCredential)
 163     {
 164         SecurePackage *package = (SecurePackage *)phCredential->dwUpper;
 165         PCredHandle cred = (PCredHandle)phCredential->dwLower;
 166
 167         if (package && package->provider &&
 168          package->provider->fnTableW.FreeCredentialsHandle)
 169             ret = package->provider->fnTableW.FreeCredentialsHandle(cred);
 170         else
 171             ret = SEC_E_INVALID_HANDLE;
 172         HeapFree(GetProcessHeap(), 0, cred);
 173     }
 174     else
 175         ret = SEC_E_INVALID_HANDLE;
 176     return ret;
 177 }
 178
 179 /***********************************************************************
 180  *              QueryCredentialsAttributesA (SECUR32.@)
 181  */
 182 SECURITY_STATUS WINAPI QueryCredentialsAttributesA(
 183  PCredHandle phCredential, ULONG ulAttribute, void *pBuffer)
 184 {
 185     SECURITY_STATUS ret;
 186
 187     TRACE("%p %d %p\n", phCredential, ulAttribute, pBuffer);
 188     if (phCredential)
 189     {
 190         SecurePackage *package = (SecurePackage *)phCredential->dwUpper;
 191         PCredHandle cred = (PCredHandle)phCredential->dwLower;
 192
 193         if (package && package->provider)
 194         {
 195             if (package->provider->fnTableA.QueryCredentialsAttributesA)
 196                 ret = package->provider->fnTableA.QueryCredentialsAttributesA(
 197                  cred, ulAttribute, pBuffer);
 198             else
 199                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 200         }
 201         else
 202             ret = SEC_E_INVALID_HANDLE;
 203     }
 204     else
 205         ret = SEC_E_INVALID_HANDLE;
 206     return ret;
 207 }
 208
 209 /***********************************************************************
 210  *              QueryCredentialsAttributesW (SECUR32.@)
 211  */
 212 SECURITY_STATUS WINAPI QueryCredentialsAttributesW(
 213  PCredHandle phCredential, ULONG ulAttribute, void *pBuffer)
 214 {
 215     SECURITY_STATUS ret;
 216
 217     TRACE("%p %d %p\n", phCredential, ulAttribute, pBuffer);
 218     if (phCredential)
 219     {
 220         SecurePackage *package = (SecurePackage *)phCredential->dwUpper;
 221         PCredHandle cred = (PCredHandle)phCredential->dwLower;
 222
 223         if (package && package->provider)
 224         {
 225             if (package->provider->fnTableW.QueryCredentialsAttributesW)
 226                 ret = package->provider->fnTableW.QueryCredentialsAttributesW(
 227                  cred, ulAttribute, pBuffer);
 228             else
 229                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 230         }
 231         else
 232             ret = SEC_E_INVALID_HANDLE;
 233     }
 234     else
 235         ret = SEC_E_INVALID_HANDLE;
 236     return ret;
 237 }
 238
 239 /***********************************************************************
 240  *              InitializeSecurityContextA (SECUR32.@)
 241  */
 242 SECURITY_STATUS WINAPI InitializeSecurityContextA(
 243  PCredHandle phCredential, PCtxtHandle phContext,
 244  SEC_CHAR *pszTargetName, ULONG fContextReq,
 245  ULONG Reserved1, ULONG TargetDataRep, PSecBufferDesc pInput,
 246  ULONG Reserved2, PCtxtHandle phNewContext, PSecBufferDesc pOutput,
 247  ULONG *pfContextAttr, PTimeStamp ptsExpiry)
 248 {
 249     SECURITY_STATUS ret;
 250     SecurePackage *package = NULL;
 251     PCredHandle cred = NULL;
 252     PCredHandle ctxt = NULL;
 253
 254     TRACE("%p %p %s 0x%08x %d %d %p %d %p %p %p %p\n", phCredential, phContext,
 255      debugstr_a(pszTargetName), fContextReq, Reserved1, TargetDataRep, pInput,
 256      Reserved1, phNewContext, pOutput, pfContextAttr, ptsExpiry);
 257
 258     if (phContext)
 259     {
 260         package = (SecurePackage *)phContext->dwUpper;
 261         ctxt = (PCtxtHandle)phContext->dwLower;
 262     }
 263     if (phCredential)
 264     {
 265         package = (SecurePackage *)phCredential->dwUpper;
 266         cred = (PCredHandle)phCredential->dwLower;
 267     }
 268
 269     if (package && package->provider)
 270     {
 271         if (package->provider->fnTableA.InitializeSecurityContextA)
 272         {
 273             CtxtHandle myCtxt;
 274
 275             if (phContext)
 276             {
 277                 PCtxtHandle realCtxt = (PCtxtHandle)phContext->dwLower;
 278                 myCtxt.dwUpper = realCtxt->dwUpper;
 279                 myCtxt.dwLower = realCtxt->dwLower;
 280             }
 281
 282             ret = package->provider->fnTableA.InitializeSecurityContextA(
 283                  cred, ctxt, pszTargetName, fContextReq,
 284                  Reserved1, TargetDataRep, pInput, Reserved2, phNewContext ? &myCtxt : NULL,
 285                  pOutput, pfContextAttr, ptsExpiry);
 286             if ((ret == SEC_E_OK || ret == SEC_I_CONTINUE_NEEDED) &&
 287                 phNewContext && phNewContext != phContext)
 288             {
 289                 SECURITY_STATUS ret2;
 290                 ret2 = SECUR32_makeSecHandle(phNewContext, package, &myCtxt);
 291                 if (ret2 != SEC_E_OK)
 292                     package->provider->fnTableA.DeleteSecurityContext(&myCtxt);
 293             }
 294         }
 295         else
 296             ret = SEC_E_UNSUPPORTED_FUNCTION;
 297     }
 298     else
 299         ret = SEC_E_INVALID_HANDLE;
 300     return ret;
 301 }
 302
 303 /***********************************************************************
 304  *              InitializeSecurityContextW (SECUR32.@)
 305  */
 306 SECURITY_STATUS WINAPI InitializeSecurityContextW(
 307  PCredHandle phCredential, PCtxtHandle phContext,
 308  SEC_WCHAR *pszTargetName, ULONG fContextReq,
 309  ULONG Reserved1, ULONG TargetDataRep, PSecBufferDesc pInput,
 310  ULONG Reserved2, PCtxtHandle phNewContext, PSecBufferDesc pOutput,
 311  ULONG *pfContextAttr, PTimeStamp ptsExpiry)
 312 {
 313     SECURITY_STATUS ret;
 314     SecurePackage *package = NULL;
 315     PCredHandle cred = NULL;
 316     PCredHandle ctxt = NULL;
 317
 318     TRACE("%p %p %s %d %d %d %p %d %p %p %p %p\n", phCredential, phContext,
 319      debugstr_w(pszTargetName), fContextReq, Reserved1, TargetDataRep, pInput,
 320      Reserved1, phNewContext, pOutput, pfContextAttr, ptsExpiry);
 321
 322     if (phContext)
 323     {
 324         package = (SecurePackage *)phContext->dwUpper;
 325         ctxt = (PCtxtHandle)phContext->dwLower;
 326     }
 327     if (phCredential)
 328     {
 329         package = (SecurePackage *)phCredential->dwUpper;
 330         cred = (PCredHandle)phCredential->dwLower;
 331     }
 332
 333     if (package && package->provider)
 334     {
 335         if (package->provider->fnTableW.InitializeSecurityContextW)
 336         {
 337             CtxtHandle myCtxt;
 338
 339             if (phContext)
 340             {
 341                 PCtxtHandle realCtxt = (PCtxtHandle)phContext->dwLower;
 342                 myCtxt.dwUpper = realCtxt->dwUpper;
 343                 myCtxt.dwLower = realCtxt->dwLower;
 344             }
 345
 346             ret = package->provider->fnTableW.InitializeSecurityContextW(
 347                  cred, ctxt, pszTargetName, fContextReq,
 348                  Reserved1, TargetDataRep, pInput, Reserved2, phNewContext ? &myCtxt : NULL,
 349                  pOutput, pfContextAttr, ptsExpiry);
 350             if ((ret == SEC_E_OK || ret == SEC_I_CONTINUE_NEEDED) &&
 351                 phNewContext && phNewContext != phContext)
 352             {
 353                 SECURITY_STATUS ret2;
 354                 ret2 = SECUR32_makeSecHandle(phNewContext, package, &myCtxt);
 355                 if (ret2 != SEC_E_OK)
 356                     package->provider->fnTableW.DeleteSecurityContext(&myCtxt);
 357             }
 358         }
 359         else
 360             ret = SEC_E_UNSUPPORTED_FUNCTION;
 361     }
 362     else
 363         ret = SEC_E_INVALID_HANDLE;
 364     return ret;
 365 }
 366
 367 /***********************************************************************
 368  *              AcceptSecurityContext (SECUR32.@)
 369  */
 370 SECURITY_STATUS WINAPI AcceptSecurityContext(
 371  PCredHandle phCredential, PCtxtHandle phContext, PSecBufferDesc pInput,
 372  ULONG fContextReq, ULONG TargetDataRep, PCtxtHandle phNewContext,
 373  PSecBufferDesc pOutput, ULONG *pfContextAttr, PTimeStamp ptsExpiry)
 374 {
 375     SECURITY_STATUS ret;
 376
 377     TRACE("%p %p %p %d %d %p %p %p %p\n", phCredential, phContext, pInput,
 378      fContextReq, TargetDataRep, phNewContext, pOutput, pfContextAttr,
 379      ptsExpiry);
 380     if (phCredential)
 381     {
 382         SecurePackage *package = (SecurePackage *)phCredential->dwUpper;
 383         PCredHandle cred = (PCredHandle)phCredential->dwLower;
 384
 385         if (package && package->provider)
 386         {
 387             if (package->provider->fnTableW.AcceptSecurityContext)
 388             {
 389                 CtxtHandle myCtxt;
 390
 391                 if(phContext)
 392                 {
 393                     PCtxtHandle realCtxt = (PCtxtHandle)phContext->dwLower;
 394                     TRACE("realCtx: %p\n", realCtxt);
 395                     myCtxt.dwUpper = realCtxt->dwUpper;
 396                     myCtxt.dwLower = realCtxt->dwLower;
 397                 }
 398
 399                 ret = package->provider->fnTableW.AcceptSecurityContext(
 400                  cred, phContext ? &myCtxt : NULL, pInput, fContextReq,
 401                  TargetDataRep, &myCtxt, pOutput, pfContextAttr, ptsExpiry);
 402                 if (ret == SEC_E_OK || ret == SEC_I_CONTINUE_NEEDED)
 403                 {
 404                     SECURITY_STATUS ret2;
 405                     ret2 = SECUR32_makeSecHandle(phNewContext, package, &myCtxt);
 406                     if (ret2 != SEC_E_OK)
 407                         package->provider->fnTableW.DeleteSecurityContext(
 408                          &myCtxt);
 409                 }
 410             }
 411             else
 412                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 413         }
 414         else
 415             ret = SEC_E_INVALID_HANDLE;
 416     }
 417     else
 418         ret = SEC_E_INVALID_HANDLE;
 419     return ret;
 420 }
 421
 422 /***********************************************************************
 423  *              CompleteAuthToken (SECUR32.@)
 424  */
 425 SECURITY_STATUS WINAPI CompleteAuthToken(PCtxtHandle phContext,
 426  PSecBufferDesc pToken)
 427 {
 428     SECURITY_STATUS ret;
 429
 430     TRACE("%p %p\n", phContext, pToken);
 431     if (phContext)
 432     {
 433         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
 434         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
 435
 436         if (package && package->provider)
 437         {
 438             if (package->provider->fnTableW.CompleteAuthToken)
 439                 ret = package->provider->fnTableW.CompleteAuthToken(ctxt,
 440                  pToken);
 441             else
 442                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 443         }
 444         else
 445             ret = SEC_E_INVALID_HANDLE;
 446     }
 447     else
 448         ret = SEC_E_INVALID_HANDLE;
 449     return ret;
 450 }
 451
 452 /***********************************************************************
 453  *              DeleteSecurityContext (SECUR32.@)
 454  */
 455 SECURITY_STATUS WINAPI DeleteSecurityContext(PCtxtHandle phContext)
 456 {
 457     SECURITY_STATUS ret;
 458
 459     TRACE("%p\n", phContext);
 460     if (phContext)
 461     {
 462         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
 463         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
 464
 465         if (package && package->provider &&
 466          package->provider->fnTableW.DeleteSecurityContext)
 467             ret = package->provider->fnTableW.DeleteSecurityContext(ctxt);
 468         else
 469             ret = SEC_E_INVALID_HANDLE;
 470         HeapFree(GetProcessHeap(), 0, ctxt);
 471     }
 472     else
 473         ret = SEC_E_INVALID_HANDLE;
 474     return ret;
 475 }
 476
 477 /***********************************************************************
 478  *              ApplyControlToken (SECUR32.@)
 479  */
 480 SECURITY_STATUS WINAPI ApplyControlToken(PCtxtHandle phContext,
 481  PSecBufferDesc pInput)
 482 {
 483     SECURITY_STATUS ret;
 484
 485     TRACE("%p %p\n", phContext, pInput);
 486     if (phContext)
 487     {
 488         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
 489         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
 490
 491         if (package && package->provider)
 492         {
 493             if (package->provider->fnTableW.ApplyControlToken)
 494                 ret = package->provider->fnTableW.ApplyControlToken(
 495                  ctxt, pInput);
 496             else
 497                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 498         }
 499         else
 500             ret = SEC_E_INVALID_HANDLE;
 501     }
 502     else
 503         ret = SEC_E_INVALID_HANDLE;
 504     return ret;
 505 }
 506
 507 /***********************************************************************
 508  *              QueryContextAttributesA (SECUR32.@)
 509  */
 510 SECURITY_STATUS WINAPI QueryContextAttributesA(PCtxtHandle phContext,
 511  ULONG ulAttribute, void *pBuffer)
 512 {
 513     SECURITY_STATUS ret;
 514
 515     TRACE("%p %d %p\n", phContext, ulAttribute, pBuffer);
 516     if (phContext)
 517     {
 518         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
 519         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
 520
 521         if (package && package->provider)
 522         {
 523             if (package->provider->fnTableA.QueryContextAttributesA)
 524                 ret = package->provider->fnTableA.QueryContextAttributesA(
 525                  ctxt, ulAttribute, pBuffer);
 526             else
 527                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 528         }
 529         else
 530             ret = SEC_E_INVALID_HANDLE;
 531     }
 532     else
 533         ret = SEC_E_INVALID_HANDLE;
 534     return ret;
 535 }
 536
 537 /***********************************************************************
 538  *              QueryContextAttributesW (SECUR32.@)
 539  */
 540 SECURITY_STATUS WINAPI QueryContextAttributesW(PCtxtHandle phContext,
 541  ULONG ulAttribute, void *pBuffer)
 542 {
 543     SECURITY_STATUS ret;
 544
 545     TRACE("%p %d %p\n", phContext, ulAttribute, pBuffer);
 546     if (phContext)
 547     {
 548         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
 549         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
 550
 551         if (package && package->provider)
 552         {
 553             if (package->provider->fnTableW.QueryContextAttributesW)
 554                 ret = package->provider->fnTableW.QueryContextAttributesW(
 555                  ctxt, ulAttribute, pBuffer);
 556             else
 557                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 558         }
 559         else
 560             ret = SEC_E_INVALID_HANDLE;
 561     }
 562     else
 563         ret = SEC_E_INVALID_HANDLE;
 564     return ret;
 565 }
 566
 567 /***********************************************************************
 568  *              ImpersonateSecurityContext (SECUR32.@)
 569  */
 570 SECURITY_STATUS WINAPI ImpersonateSecurityContext(PCtxtHandle phContext)
 571 {
 572     SECURITY_STATUS ret;
 573
 574     TRACE("%p\n", phContext);
 575     if (phContext)
 576     {
 577         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
 578         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
 579
 580         if (package && package->provider)
 581         {
 582             if (package->provider->fnTableW.ImpersonateSecurityContext)
 583                 ret = package->provider->fnTableW.ImpersonateSecurityContext(
 584                  ctxt);
 585             else
 586                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 587         }
 588         else
 589             ret = SEC_E_INVALID_HANDLE;
 590     }
 591     else
 592         ret = SEC_E_INVALID_HANDLE;
 593     return ret;
 594 }
 595
 596 /***********************************************************************
 597  *              RevertSecurityContext (SECUR32.@)
 598  */
 599 SECURITY_STATUS WINAPI RevertSecurityContext(PCtxtHandle phContext)
 600 {
 601     SECURITY_STATUS ret;
 602
 603     TRACE("%p\n", phContext);
 604     if (phContext)
 605     {
 606         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
 607         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
 608
 609         if (package && package->provider)
 610         {
 611             if (package->provider->fnTableW.RevertSecurityContext)
 612                 ret = package->provider->fnTableW.RevertSecurityContext(
 613                  ctxt);
 614             else
 615                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 616         }
 617         else
 618             ret = SEC_E_INVALID_HANDLE;
 619     }
 620     else
 621         ret = SEC_E_INVALID_HANDLE;
 622     return ret;
 623 }
 624
 625 /***********************************************************************
 626  *              MakeSignature (SECUR32.@)
 627  */
 628 SECURITY_STATUS WINAPI MakeSignature(PCtxtHandle phContext, ULONG fQOP,
 629  PSecBufferDesc pMessage, ULONG MessageSeqNo)
 630 {
 631     SECURITY_STATUS ret;
 632
 633     TRACE("%p %d %p %d\n", phContext, fQOP, pMessage, MessageSeqNo);
 634     if (phContext)
 635     {
 636         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
 637         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
 638
 639         if (package && package->provider)
 640         {
 641             if (package->provider->fnTableW.MakeSignature)
 642                 ret = package->provider->fnTableW.MakeSignature(
 643                  ctxt, fQOP, pMessage, MessageSeqNo);
 644             else
 645                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 646         }
 647         else
 648             ret = SEC_E_INVALID_HANDLE;
 649     }
 650     else
 651         ret = SEC_E_INVALID_HANDLE;
 652     return ret;
 653 }
 654
 655 /***********************************************************************
 656  *              VerifySignature (SECUR32.@)
 657  */
 658 SECURITY_STATUS WINAPI VerifySignature(PCtxtHandle phContext,
 659  PSecBufferDesc pMessage, ULONG MessageSeqNo, PULONG pfQOP)
 660 {
 661     SECURITY_STATUS ret;
 662
 663     TRACE("%p %p %d %p\n", phContext, pMessage, MessageSeqNo, pfQOP);
 664     if (phContext)
 665     {
 666         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
 667         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
 668
 669         if (package && package->provider)
 670         {
 671             if (package->provider->fnTableW.VerifySignature)
 672                 ret = package->provider->fnTableW.VerifySignature(
 673                  ctxt, pMessage, MessageSeqNo, pfQOP);
 674             else
 675                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 676         }
 677         else
 678             ret = SEC_E_INVALID_HANDLE;
 679     }
 680     else
 681         ret = SEC_E_INVALID_HANDLE;
 682     return ret;
 683 }
 684
 685 /***********************************************************************
 686  *              QuerySecurityPackageInfoA (SECUR32.@)
 687  */
 688 SECURITY_STATUS WINAPI QuerySecurityPackageInfoA(SEC_CHAR *pszPackageName,
 689  PSecPkgInfoA *ppPackageInfo)
 690 {
 691     SECURITY_STATUS ret;
 692
 693     TRACE("%s %p\n", debugstr_a(pszPackageName), ppPackageInfo);
 694     if (pszPackageName)
 695     {
 696         SecurePackage *package = SECUR32_findPackageA(pszPackageName);
 697
 698         if (package)
 699         {
 700             size_t bytesNeeded = sizeof(SecPkgInfoA);
 701             int nameLen = 0, commentLen = 0;
 702
 703             if (package->infoW.Name)
 704             {
 705                 nameLen = WideCharToMultiByte(CP_ACP, 0,
 706                  package->infoW.Name, -1, NULL, 0, NULL, NULL);
 707                 bytesNeeded += nameLen;
 708             }
 709             if (package->infoW.Comment)
 710             {
 711                 commentLen = WideCharToMultiByte(CP_ACP, 0,
 712                  package->infoW.Comment, -1, NULL, 0, NULL, NULL);
 713                 bytesNeeded += commentLen;
 714             }
 715             *ppPackageInfo = HeapAlloc(GetProcessHeap(), 0, bytesNeeded);
 716             if (*ppPackageInfo)
 717             {
 718                 PSTR nextString = (PSTR)((PBYTE)*ppPackageInfo +
 719                  sizeof(SecPkgInfoA));
 720
 721                 memcpy(*ppPackageInfo, &package->infoW, sizeof(package->infoW));
 722                 if (package->infoW.Name)
 723                 {
 724                     (*ppPackageInfo)->Name = nextString;
 725                     nextString += WideCharToMultiByte(CP_ACP, 0,
 726                      package->infoW.Name, -1, nextString, nameLen, NULL, NULL);
 727                 }
 728                 else
 729                     (*ppPackageInfo)->Name = NULL;
 730                 if (package->infoW.Comment)
 731                 {
 732                     (*ppPackageInfo)->Comment = nextString;
 733                     nextString += WideCharToMultiByte(CP_ACP, 0,
 734                      package->infoW.Comment, -1, nextString, commentLen, NULL,
 735                      NULL);
 736                 }
 737                 else
 738                     (*ppPackageInfo)->Comment = NULL;
 739                 ret = SEC_E_OK;
 740             }
 741             else
 742                 ret = SEC_E_INSUFFICIENT_MEMORY;
 743         }
 744         else
 745             ret = SEC_E_SECPKG_NOT_FOUND;
 746     }
 747     else
 748         ret = SEC_E_SECPKG_NOT_FOUND;
 749     return ret;
 750 }
 751
 752 /***********************************************************************
 753  *              QuerySecurityPackageInfoW (SECUR32.@)
 754  */
 755 SECURITY_STATUS WINAPI QuerySecurityPackageInfoW(SEC_WCHAR *pszPackageName,
 756  PSecPkgInfoW *ppPackageInfo)
 757 {
 758     SECURITY_STATUS ret;
 759     SecurePackage *package = SECUR32_findPackageW(pszPackageName);
 760
 761     TRACE("%s %p\n", debugstr_w(pszPackageName), ppPackageInfo);
 762     if (package)
 763     {
 764         size_t bytesNeeded = sizeof(SecPkgInfoW);
 765         int nameLen = 0, commentLen = 0;
 766
 767         if (package->infoW.Name)
 768         {
 769             nameLen = lstrlenW(package->infoW.Name) + 1;
 770             bytesNeeded += nameLen * sizeof(WCHAR);
 771         }
 772         if (package->infoW.Comment)
 773         {
 774             commentLen = lstrlenW(package->infoW.Comment) + 1;
 775             bytesNeeded += commentLen * sizeof(WCHAR);
 776         }
 777         *ppPackageInfo = HeapAlloc(GetProcessHeap(), 0, bytesNeeded);
 778         if (*ppPackageInfo)
 779         {
 780             PWSTR nextString = (PWSTR)((PBYTE)*ppPackageInfo +
 781              sizeof(SecPkgInfoW));
 782
 783             **ppPackageInfo = package->infoW;
 784             if (package->infoW.Name)
 785             {
 786                 (*ppPackageInfo)->Name = nextString;
 787                 lstrcpynW(nextString, package->infoW.Name, nameLen);
 788                 nextString += nameLen;
 789             }
 790             else
 791                 (*ppPackageInfo)->Name = NULL;
 792             if (package->infoW.Comment)
 793             {
 794                 (*ppPackageInfo)->Comment = nextString;
 795                 lstrcpynW(nextString, package->infoW.Comment, commentLen);
 796                 nextString += commentLen;
 797             }
 798             else
 799                 (*ppPackageInfo)->Comment = NULL;
 800             ret = SEC_E_OK;
 801         }
 802         else
 803             ret = SEC_E_INSUFFICIENT_MEMORY;
 804     }
 805     else
 806         ret = SEC_E_SECPKG_NOT_FOUND;
 807     return ret;
 808 }
 809
 810 /***********************************************************************
 811  *              ExportSecurityContext (SECUR32.@)
 812  */
 813 SECURITY_STATUS WINAPI ExportSecurityContext(PCtxtHandle phContext,
 814  ULONG fFlags, PSecBuffer pPackedContext, void **pToken)
 815 {
 816     SECURITY_STATUS ret;
 817
 818     TRACE("%p %d %p %p\n", phContext, fFlags, pPackedContext, pToken);
 819     if (phContext)
 820     {
 821         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
 822         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
 823
 824         if (package && package->provider)
 825         {
 826             if (package->provider->fnTableW.ExportSecurityContext)
 827                 ret = package->provider->fnTableW.ExportSecurityContext(
 828                  ctxt, fFlags, pPackedContext, pToken);
 829             else
 830                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 831         }
 832         else
 833             ret = SEC_E_INVALID_HANDLE;
 834     }
 835     else
 836         ret = SEC_E_INVALID_HANDLE;
 837     return ret;
 838 }
 839
 840 /***********************************************************************
 841  *              ImportSecurityContextA (SECUR32.@)
 842  */
 843 SECURITY_STATUS WINAPI ImportSecurityContextA(SEC_CHAR *pszPackage,
 844  PSecBuffer pPackedContext, void *Token, PCtxtHandle phContext)
 845 {
 846     SECURITY_STATUS ret;
 847     SecurePackage *package = SECUR32_findPackageA(pszPackage);
 848
 849     TRACE("%s %p %p %p\n", debugstr_a(pszPackage), pPackedContext, Token,
 850      phContext);
 851     if (package && package->provider)
 852     {
 853         if (package->provider->fnTableA.ImportSecurityContextA)
 854         {
 855             CtxtHandle myCtxt;
 856
 857             ret = package->provider->fnTableA.ImportSecurityContextA(
 858              pszPackage, pPackedContext, Token, &myCtxt);
 859             if (ret == SEC_E_OK)
 860             {
 861                 ret = SECUR32_makeSecHandle(phContext, package, &myCtxt);
 862                 if (ret != SEC_E_OK)
 863                     package->provider->fnTableW.DeleteSecurityContext(&myCtxt);
 864             }
 865         }
 866         else
 867             ret = SEC_E_UNSUPPORTED_FUNCTION;
 868     }
 869     else
 870         ret = SEC_E_SECPKG_NOT_FOUND;
 871     return ret;
 872
 873 }
 874
 875 /***********************************************************************
 876  *              ImportSecurityContextW (SECUR32.@)
 877  */
 878 SECURITY_STATUS WINAPI ImportSecurityContextW(SEC_WCHAR *pszPackage,
 879  PSecBuffer pPackedContext, void *Token, PCtxtHandle phContext)
 880 {
 881     SECURITY_STATUS ret;
 882     SecurePackage *package = SECUR32_findPackageW(pszPackage);
 883
 884     TRACE("%s %p %p %p\n", debugstr_w(pszPackage), pPackedContext, Token,
 885      phContext);
 886     if (package && package->provider)
 887     {
 888         if (package->provider->fnTableW.ImportSecurityContextW)
 889         {
 890             CtxtHandle myCtxt;
 891
 892             ret = package->provider->fnTableW.ImportSecurityContextW(
 893              pszPackage, pPackedContext, Token, &myCtxt);
 894             if (ret == SEC_E_OK)
 895             {
 896                 ret = SECUR32_makeSecHandle(phContext, package, &myCtxt);
 897                 if (ret != SEC_E_OK)
 898                     package->provider->fnTableW.DeleteSecurityContext(&myCtxt);
 899             }
 900         }
 901         else
 902             ret = SEC_E_UNSUPPORTED_FUNCTION;
 903     }
 904     else
 905         ret = SEC_E_SECPKG_NOT_FOUND;
 906     return ret;
 907 }
 908
 909 /***********************************************************************
 910  *              AddCredentialsA (SECUR32.@)
 911  */
 912 SECURITY_STATUS WINAPI AddCredentialsA(PCredHandle hCredentials,
 913  SEC_CHAR *pszPrincipal, SEC_CHAR *pszPackage, ULONG fCredentialUse,
 914  void *pAuthData, SEC_GET_KEY_FN pGetKeyFn, void *pvGetKeyArgument,
 915  PTimeStamp ptsExpiry)
 916 {
 917     SECURITY_STATUS ret;
 918
 919     TRACE("%p %s %s %d %p %p %p %p\n", hCredentials, debugstr_a(pszPrincipal),
 920      debugstr_a(pszPackage), fCredentialUse, pAuthData, pGetKeyFn,
 921      pvGetKeyArgument, ptsExpiry);
 922     if (hCredentials)
 923     {
 924         SecurePackage *package = (SecurePackage *)hCredentials->dwUpper;
 925         PCredHandle cred = (PCtxtHandle)hCredentials->dwLower;
 926
 927         if (package && package->provider)
 928         {
 929             if (package->provider->fnTableA.AddCredentialsA)
 930                 ret = package->provider->fnTableA.AddCredentialsA(
 931                  cred, pszPrincipal, pszPackage, fCredentialUse, pAuthData,
 932                  pGetKeyFn, pvGetKeyArgument, ptsExpiry);
 933             else
 934                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 935         }
 936         else
 937             ret = SEC_E_INVALID_HANDLE;
 938     }
 939     else
 940         ret = SEC_E_INVALID_HANDLE;
 941     return ret;
 942 }
 943
 944 /***********************************************************************
 945  *              AddCredentialsW (SECUR32.@)
 946  */
 947 SECURITY_STATUS WINAPI AddCredentialsW(PCredHandle hCredentials,
 948  SEC_WCHAR *pszPrincipal, SEC_WCHAR *pszPackage, ULONG fCredentialUse,
 949  void *pAuthData, SEC_GET_KEY_FN pGetKeyFn, void *pvGetKeyArgument,
 950  PTimeStamp ptsExpiry)
 951 {
 952     SECURITY_STATUS ret;
 953
 954     TRACE("%p %s %s %d %p %p %p %p\n", hCredentials, debugstr_w(pszPrincipal),
 955      debugstr_w(pszPackage), fCredentialUse, pAuthData, pGetKeyFn,
 956      pvGetKeyArgument, ptsExpiry);
 957     if (hCredentials)
 958     {
 959         SecurePackage *package = (SecurePackage *)hCredentials->dwUpper;
 960         PCredHandle cred = (PCtxtHandle)hCredentials->dwLower;
 961
 962         if (package && package->provider)
 963         {
 964             if (package->provider->fnTableW.AddCredentialsW)
 965                 ret = package->provider->fnTableW.AddCredentialsW(
 966                  cred, pszPrincipal, pszPackage, fCredentialUse, pAuthData,
 967                  pGetKeyFn, pvGetKeyArgument, ptsExpiry);
 968             else
 969                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 970         }
 971         else
 972             ret = SEC_E_INVALID_HANDLE;
 973     }
 974     else
 975         ret = SEC_E_INVALID_HANDLE;
 976     return ret;
 977 }
 978
 979 /***********************************************************************
 980  *              QuerySecurityContextToken (SECUR32.@)
 981  */
 982 SECURITY_STATUS WINAPI QuerySecurityContextToken(PCtxtHandle phContext,
 983  HANDLE *phToken)
 984 {
 985     SECURITY_STATUS ret;
 986
 987     TRACE("%p %p\n", phContext, phToken);
 988     if (phContext)
 989     {
 990         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
 991         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
 992
 993         if (package && package->provider)
 994         {
 995             if (package->provider->fnTableW.QuerySecurityContextToken)
 996                 ret = package->provider->fnTableW.QuerySecurityContextToken(
 997                  ctxt, phToken);
 998             else
 999                 ret = SEC_E_UNSUPPORTED_FUNCTION;
1000         }
1001         else
1002             ret = SEC_E_INVALID_HANDLE;
1003     }
1004     else
1005         ret = SEC_E_INVALID_HANDLE;
1006     return ret;
1007 }
1008
1009 /***********************************************************************
1010  *              EncryptMessage (SECUR32.@)
1011  */
1012 SECURITY_STATUS WINAPI EncryptMessage(PCtxtHandle phContext, ULONG fQOP,
1013  PSecBufferDesc pMessage, ULONG MessageSeqNo)
1014 {
1015     SECURITY_STATUS ret;
1016
1017     TRACE("%p %d %p %d\n", phContext, fQOP, pMessage, MessageSeqNo);
1018     if (phContext)
1019     {
1020         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
1021         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
1022
1023         if (package && package->provider)
1024         {
1025             if (package->provider->fnTableW.EncryptMessage)
1026                 ret = package->provider->fnTableW.EncryptMessage(
1027                  ctxt, fQOP, pMessage, MessageSeqNo);
1028             else
1029                 ret = SEC_E_UNSUPPORTED_FUNCTION;
1030         }
1031         else
1032             ret = SEC_E_INVALID_HANDLE;
1033     }
1034     else
1035         ret = SEC_E_INVALID_HANDLE;
1036     return ret;
1037 }
1038
1039 /***********************************************************************
1040  *              DecryptMessage (SECUR32.@)
1041  */
1042 SECURITY_STATUS WINAPI DecryptMessage(PCtxtHandle phContext,
1043  PSecBufferDesc pMessage, ULONG MessageSeqNo, PULONG pfQOP)
1044 {
1045     SECURITY_STATUS ret;
1046
1047     TRACE("%p %p %d %p\n", phContext, pMessage, MessageSeqNo, pfQOP);
1048     if (phContext)
1049     {
1050         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
1051         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
1052
1053         if (package && package->provider)
1054         {
1055             if (package->provider->fnTableW.DecryptMessage)
1056                 ret = package->provider->fnTableW.DecryptMessage(
1057                  ctxt, pMessage, MessageSeqNo, pfQOP);
1058             else
1059                 ret = SEC_E_UNSUPPORTED_FUNCTION;
1060         }
1061         else
1062             ret = SEC_E_INVALID_HANDLE;
1063     }
1064     else
1065         ret = SEC_E_INVALID_HANDLE;
1066     return ret;
1067 }
1068
1069 /***********************************************************************
1070  *              SetContextAttributesA (SECUR32.@)
1071  */
1072 SECURITY_STATUS WINAPI SetContextAttributesA(PCtxtHandle phContext,
1073  ULONG ulAttribute, void *pBuffer, ULONG cbBuffer)
1074 {
1075     SECURITY_STATUS ret;
1076
1077     TRACE("%p %d %p %d\n", phContext, ulAttribute, pBuffer, cbBuffer);
1078     if (phContext)
1079     {
1080         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
1081         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
1082
1083         if (package && package->provider)
1084         {
1085             if (package->provider->fnTableA.SetContextAttributesA)
1086                 ret = package->provider->fnTableA.SetContextAttributesA(
1087                  ctxt, ulAttribute, pBuffer, cbBuffer);
1088             else
1089                 ret = SEC_E_UNSUPPORTED_FUNCTION;
1090         }
1091         else
1092             ret = SEC_E_INVALID_HANDLE;
1093     }
1094     else
1095         ret = SEC_E_INVALID_HANDLE;
1096     return ret;
1097 }
1098
1099 /***********************************************************************
1100  *              SetContextAttributesW (SECUR32.@)
1101  */
1102 SECURITY_STATUS WINAPI SetContextAttributesW(PCtxtHandle phContext,
1103  ULONG ulAttribute, void *pBuffer, ULONG cbBuffer)
1104 {
1105     SECURITY_STATUS ret;
1106
1107     TRACE("%p %d %p %d\n", phContext, ulAttribute, pBuffer, cbBuffer);
1108     if (phContext)
1109     {
1110         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
1111         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
1112
1113         if (package && package->provider)
1114         {
1115             if (package->provider->fnTableW.SetContextAttributesW)
1116                 ret = package->provider->fnTableW.SetContextAttributesW(
1117                  ctxt, ulAttribute, pBuffer, cbBuffer);
1118             else
1119                 ret = SEC_E_UNSUPPORTED_FUNCTION;
1120         }
1121         else
1122             ret = SEC_E_INVALID_HANDLE;
1123     }
1124     else
1125         ret = SEC_E_INVALID_HANDLE;
1126     return ret;
1127 }