[SECUR32] Reduce difference with Wine Staging 1.7.55. NFC. CORE-10536
[reactos.git] / reactos / dll / win32 / 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 "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 }