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