source: trunk/src/secur32/wrapper.c@ 21787

Last change on this file since 21787 was 21364, checked in by vladest, 16 years ago
  • Added SSP DLLs loader. Still under development. Do not use in working configurations
File size: 35.5 KB
Line 
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#include "winerror.h"
28WINE_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 */
35static 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 */
64SECURITY_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 */
110SECURITY_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 */
156SECURITY_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 */
182SECURITY_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 */
212SECURITY_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 */
242SECURITY_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 %d %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) && phNewContext)
287 {
288 SECURITY_STATUS ret2;
289 ret2 = SECUR32_makeSecHandle(phNewContext, package, &myCtxt);
290 if (ret2 != SEC_E_OK)
291 package->provider->fnTableA.DeleteSecurityContext(&myCtxt);
292 }
293 }
294 else
295 ret = SEC_E_UNSUPPORTED_FUNCTION;
296 }
297 else
298 ret = SEC_E_INVALID_HANDLE;
299 return ret;
300}
301
302/***********************************************************************
303 * InitializeSecurityContextW (SECUR32.@)
304 */
305SECURITY_STATUS WINAPI InitializeSecurityContextW(
306 PCredHandle phCredential, PCtxtHandle phContext,
307 SEC_WCHAR *pszTargetName, ULONG fContextReq,
308 ULONG Reserved1, ULONG TargetDataRep, PSecBufferDesc pInput,
309 ULONG Reserved2, PCtxtHandle phNewContext, PSecBufferDesc pOutput,
310 ULONG *pfContextAttr, PTimeStamp ptsExpiry)
311{
312 SECURITY_STATUS ret;
313 SecurePackage *package = NULL;
314 PCredHandle cred = NULL;
315 PCredHandle ctxt = NULL;
316
317 TRACE("%p %p %s %d %d %d %p %d %p %p %p %p\n", phCredential, phContext,
318 debugstr_w(pszTargetName), fContextReq, Reserved1, TargetDataRep, pInput,
319 Reserved1, phNewContext, pOutput, pfContextAttr, ptsExpiry);
320
321 if (phContext)
322 {
323 package = (SecurePackage *)phContext->dwUpper;
324 ctxt = (PCtxtHandle)phContext->dwLower;
325 }
326 if (phCredential)
327 {
328 package = (SecurePackage *)phCredential->dwUpper;
329 cred = (PCredHandle)phCredential->dwLower;
330 }
331
332 if (package && package->provider)
333 {
334 if (package->provider->fnTableW.InitializeSecurityContextW)
335 {
336 CtxtHandle myCtxt;
337
338 if (phContext)
339 {
340 PCtxtHandle realCtxt = (PCtxtHandle)phContext->dwLower;
341 myCtxt.dwUpper = realCtxt->dwUpper;
342 myCtxt.dwLower = realCtxt->dwLower;
343 }
344
345 ret = package->provider->fnTableW.InitializeSecurityContextW(
346 cred, ctxt, pszTargetName, fContextReq,
347 Reserved1, TargetDataRep, pInput, Reserved2, phNewContext ? &myCtxt : NULL,
348 pOutput, pfContextAttr, ptsExpiry);
349 if ((ret == SEC_E_OK || ret == SEC_I_CONTINUE_NEEDED) && phNewContext)
350 {
351 SECURITY_STATUS ret2;
352 ret2 = SECUR32_makeSecHandle(phNewContext, package, &myCtxt);
353 if (ret2 != SEC_E_OK)
354 package->provider->fnTableW.DeleteSecurityContext(&myCtxt);
355 }
356 }
357 else
358 ret = SEC_E_UNSUPPORTED_FUNCTION;
359 }
360 else
361 ret = SEC_E_INVALID_HANDLE;
362 return ret;
363}
364
365/***********************************************************************
366 * AcceptSecurityContext (SECUR32.@)
367 */
368SECURITY_STATUS WINAPI AcceptSecurityContext(
369 PCredHandle phCredential, PCtxtHandle phContext, PSecBufferDesc pInput,
370 ULONG fContextReq, ULONG TargetDataRep, PCtxtHandle phNewContext,
371 PSecBufferDesc pOutput, ULONG *pfContextAttr, PTimeStamp ptsExpiry)
372{
373 SECURITY_STATUS ret;
374
375 TRACE("%p %p %p %d %d %p %p %p %p\n", phCredential, phContext, pInput,
376 fContextReq, TargetDataRep, phNewContext, pOutput, pfContextAttr,
377 ptsExpiry);
378 if (phCredential)
379 {
380 SecurePackage *package = (SecurePackage *)phCredential->dwUpper;
381 PCredHandle cred = (PCredHandle)phCredential->dwLower;
382
383 if (package && package->provider)
384 {
385 if (package->provider->fnTableW.AcceptSecurityContext)
386 {
387 CtxtHandle myCtxt;
388
389 if(phContext)
390 {
391 PCtxtHandle realCtxt = (PCtxtHandle)phContext->dwLower;
392 TRACE("realCtx: %p\n", realCtxt);
393 myCtxt.dwUpper = realCtxt->dwUpper;
394 myCtxt.dwLower = realCtxt->dwLower;
395 }
396
397 ret = package->provider->fnTableW.AcceptSecurityContext(
398 cred, phContext ? &myCtxt : NULL, pInput, fContextReq,
399 TargetDataRep, &myCtxt, pOutput, pfContextAttr, ptsExpiry);
400 if (ret == SEC_E_OK || ret == SEC_I_CONTINUE_NEEDED)
401 {
402 SECURITY_STATUS ret2;
403 ret2 = SECUR32_makeSecHandle(phNewContext, package, &myCtxt);
404 if (ret2 != SEC_E_OK)
405 package->provider->fnTableW.DeleteSecurityContext(
406 &myCtxt);
407 }
408 }
409 else
410 ret = SEC_E_UNSUPPORTED_FUNCTION;
411 }
412 else
413 ret = SEC_E_INVALID_HANDLE;
414 }
415 else
416 ret = SEC_E_INVALID_HANDLE;
417 return ret;
418}
419
420/***********************************************************************
421 * CompleteAuthToken (SECUR32.@)
422 */
423SECURITY_STATUS WINAPI CompleteAuthToken(PCtxtHandle phContext,
424 PSecBufferDesc pToken)
425{
426 SECURITY_STATUS ret;
427
428 TRACE("%p %p\n", phContext, pToken);
429 if (phContext)
430 {
431 SecurePackage *package = (SecurePackage *)phContext->dwUpper;
432 PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
433
434 if (package && package->provider)
435 {
436 if (package->provider->fnTableW.CompleteAuthToken)
437 ret = package->provider->fnTableW.CompleteAuthToken(ctxt,
438 pToken);
439 else
440 ret = SEC_E_UNSUPPORTED_FUNCTION;
441 }
442 else
443 ret = SEC_E_INVALID_HANDLE;
444 }
445 else
446 ret = SEC_E_INVALID_HANDLE;
447 return ret;
448}
449
450/***********************************************************************
451 * DeleteSecurityContext (SECUR32.@)
452 */
453SECURITY_STATUS WINAPI DeleteSecurityContext(PCtxtHandle phContext)
454{
455 SECURITY_STATUS ret;
456
457 TRACE("%p\n", phContext);
458 if (phContext)
459 {
460 SecurePackage *package = (SecurePackage *)phContext->dwUpper;
461 PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
462
463 if (package && package->provider &&
464 package->provider->fnTableW.DeleteSecurityContext)
465 ret = package->provider->fnTableW.DeleteSecurityContext(ctxt);
466 else
467 ret = SEC_E_INVALID_HANDLE;
468 HeapFree(GetProcessHeap(), 0, ctxt);
469 }
470 else
471 ret = SEC_E_INVALID_HANDLE;
472 return ret;
473}
474
475/***********************************************************************
476 * ApplyControlToken (SECUR32.@)
477 */
478SECURITY_STATUS WINAPI ApplyControlToken(PCtxtHandle phContext,
479 PSecBufferDesc pInput)
480{
481 SECURITY_STATUS ret;
482
483 TRACE("%p %p\n", phContext, pInput);
484 if (phContext)
485 {
486 SecurePackage *package = (SecurePackage *)phContext->dwUpper;
487 PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
488
489 if (package && package->provider)
490 {
491 if (package->provider->fnTableW.ApplyControlToken)
492 ret = package->provider->fnTableW.ApplyControlToken(
493 ctxt, pInput);
494 else
495 ret = SEC_E_UNSUPPORTED_FUNCTION;
496 }
497 else
498 ret = SEC_E_INVALID_HANDLE;
499 }
500 else
501 ret = SEC_E_INVALID_HANDLE;
502 return ret;
503}
504
505/***********************************************************************
506 * QueryContextAttributesA (SECUR32.@)
507 */
508SECURITY_STATUS WINAPI QueryContextAttributesA(PCtxtHandle phContext,
509 ULONG ulAttribute, void *pBuffer)
510{
511 SECURITY_STATUS ret;
512
513 TRACE("%p %d %p\n", phContext, ulAttribute, pBuffer);
514 if (phContext)
515 {
516 SecurePackage *package = (SecurePackage *)phContext->dwUpper;
517 PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
518
519 if (package && package->provider)
520 {
521 if (package->provider->fnTableA.QueryContextAttributesA)
522 ret = package->provider->fnTableA.QueryContextAttributesA(
523 ctxt, ulAttribute, pBuffer);
524 else
525 ret = SEC_E_UNSUPPORTED_FUNCTION;
526 }
527 else
528 ret = SEC_E_INVALID_HANDLE;
529 }
530 else
531 ret = SEC_E_INVALID_HANDLE;
532 return ret;
533}
534
535/***********************************************************************
536 * QueryContextAttributesW (SECUR32.@)
537 */
538SECURITY_STATUS WINAPI QueryContextAttributesW(PCtxtHandle phContext,
539 ULONG ulAttribute, void *pBuffer)
540{
541 SECURITY_STATUS ret;
542
543 TRACE("%p %d %p\n", phContext, ulAttribute, pBuffer);
544 if (phContext)
545 {
546 SecurePackage *package = (SecurePackage *)phContext->dwUpper;
547 PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
548
549 if (package && package->provider)
550 {
551 if (package->provider->fnTableW.QueryContextAttributesW)
552 ret = package->provider->fnTableW.QueryContextAttributesW(
553 ctxt, ulAttribute, pBuffer);
554 else
555 ret = SEC_E_UNSUPPORTED_FUNCTION;
556 }
557 else
558 ret = SEC_E_INVALID_HANDLE;
559 }
560 else
561 ret = SEC_E_INVALID_HANDLE;
562 return ret;
563}
564
565/***********************************************************************
566 * ImpersonateSecurityContext (SECUR32.@)
567 */
568SECURITY_STATUS WINAPI ImpersonateSecurityContext(PCtxtHandle phContext)
569{
570 SECURITY_STATUS ret;
571
572 TRACE("%p\n", phContext);
573 if (phContext)
574 {
575 SecurePackage *package = (SecurePackage *)phContext->dwUpper;
576 PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
577
578 if (package && package->provider)
579 {
580 if (package->provider->fnTableW.ImpersonateSecurityContext)
581 ret = package->provider->fnTableW.ImpersonateSecurityContext(
582 ctxt);
583 else
584 ret = SEC_E_UNSUPPORTED_FUNCTION;
585 }
586 else
587 ret = SEC_E_INVALID_HANDLE;
588 }
589 else
590 ret = SEC_E_INVALID_HANDLE;
591 return ret;
592}
593
594/***********************************************************************
595 * RevertSecurityContext (SECUR32.@)
596 */
597SECURITY_STATUS WINAPI RevertSecurityContext(PCtxtHandle phContext)
598{
599 SECURITY_STATUS ret;
600
601 TRACE("%p\n", phContext);
602 if (phContext)
603 {
604 SecurePackage *package = (SecurePackage *)phContext->dwUpper;
605 PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
606
607 if (package && package->provider)
608 {
609 if (package->provider->fnTableW.RevertSecurityContext)
610 ret = package->provider->fnTableW.RevertSecurityContext(
611 ctxt);
612 else
613 ret = SEC_E_UNSUPPORTED_FUNCTION;
614 }
615 else
616 ret = SEC_E_INVALID_HANDLE;
617 }
618 else
619 ret = SEC_E_INVALID_HANDLE;
620 return ret;
621}
622
623/***********************************************************************
624 * MakeSignature (SECUR32.@)
625 */
626SECURITY_STATUS WINAPI MakeSignature(PCtxtHandle phContext, ULONG fQOP,
627 PSecBufferDesc pMessage, ULONG MessageSeqNo)
628{
629 SECURITY_STATUS ret;
630
631 TRACE("%p %d %p %d\n", phContext, fQOP, pMessage, MessageSeqNo);
632 if (phContext)
633 {
634 SecurePackage *package = (SecurePackage *)phContext->dwUpper;
635 PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
636
637 if (package && package->provider)
638 {
639 if (package->provider->fnTableW.MakeSignature)
640 ret = package->provider->fnTableW.MakeSignature(
641 ctxt, fQOP, pMessage, MessageSeqNo);
642 else
643 ret = SEC_E_UNSUPPORTED_FUNCTION;
644 }
645 else
646 ret = SEC_E_INVALID_HANDLE;
647 }
648 else
649 ret = SEC_E_INVALID_HANDLE;
650 return ret;
651}
652
653/***********************************************************************
654 * VerifySignature (SECUR32.@)
655 */
656SECURITY_STATUS WINAPI VerifySignature(PCtxtHandle phContext,
657 PSecBufferDesc pMessage, ULONG MessageSeqNo, PULONG pfQOP)
658{
659 SECURITY_STATUS ret;
660
661 TRACE("%p %p %d %p\n", phContext, pMessage, MessageSeqNo, pfQOP);
662 if (phContext)
663 {
664 SecurePackage *package = (SecurePackage *)phContext->dwUpper;
665 PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
666
667 if (package && package->provider)
668 {
669 if (package->provider->fnTableW.VerifySignature)
670 ret = package->provider->fnTableW.VerifySignature(
671 ctxt, pMessage, MessageSeqNo, pfQOP);
672 else
673 ret = SEC_E_UNSUPPORTED_FUNCTION;
674 }
675 else
676 ret = SEC_E_INVALID_HANDLE;
677 }
678 else
679 ret = SEC_E_INVALID_HANDLE;
680 return ret;
681}
682
683/***********************************************************************
684 * QuerySecurityPackageInfoA (SECUR32.@)
685 */
686SECURITY_STATUS WINAPI QuerySecurityPackageInfoA(SEC_CHAR *pszPackageName,
687 PSecPkgInfoA *ppPackageInfo)
688{
689 SECURITY_STATUS ret;
690
691 TRACE("%s %p\n", debugstr_a(pszPackageName), ppPackageInfo);
692 if (pszPackageName)
693 {
694 SecurePackage *package = SECUR32_findPackageA(pszPackageName);
695
696 if (package)
697 {
698 size_t bytesNeeded = sizeof(SecPkgInfoA);
699 int nameLen = 0, commentLen = 0;
700
701 if (package->infoW.Name)
702 {
703 nameLen = WideCharToMultiByte(CP_ACP, 0,
704 package->infoW.Name, -1, NULL, 0, NULL, NULL);
705 bytesNeeded += nameLen;
706 }
707 if (package->infoW.Comment)
708 {
709 commentLen = WideCharToMultiByte(CP_ACP, 0,
710 package->infoW.Comment, -1, NULL, 0, NULL, NULL);
711 bytesNeeded += commentLen;
712 }
713 *ppPackageInfo = HeapAlloc(GetProcessHeap(), 0, bytesNeeded);
714 if (*ppPackageInfo)
715 {
716 PSTR nextString = (PSTR)((PBYTE)*ppPackageInfo +
717 sizeof(SecPkgInfoA));
718
719 memcpy(*ppPackageInfo, &package->infoW, sizeof(package->infoW));
720 if (package->infoW.Name)
721 {
722 (*ppPackageInfo)->Name = nextString;
723 nextString += WideCharToMultiByte(CP_ACP, 0,
724 package->infoW.Name, -1, nextString, nameLen, NULL, NULL);
725 }
726 else
727 (*ppPackageInfo)->Name = NULL;
728 if (package->infoW.Comment)
729 {
730 (*ppPackageInfo)->Comment = nextString;
731 nextString += WideCharToMultiByte(CP_ACP, 0,
732 package->infoW.Comment, -1, nextString, commentLen, NULL,
733 NULL);
734 }
735 else
736 (*ppPackageInfo)->Comment = NULL;
737 ret = SEC_E_OK;
738 }
739 else
740 ret = SEC_E_INSUFFICIENT_MEMORY;
741 }
742 else
743 ret = SEC_E_SECPKG_NOT_FOUND;
744 }
745 else
746 ret = SEC_E_SECPKG_NOT_FOUND;
747 return ret;
748}
749
750/***********************************************************************
751 * QuerySecurityPackageInfoW (SECUR32.@)
752 */
753SECURITY_STATUS WINAPI QuerySecurityPackageInfoW(SEC_WCHAR *pszPackageName,
754 PSecPkgInfoW *ppPackageInfo)
755{
756 SECURITY_STATUS ret;
757 SecurePackage *package = SECUR32_findPackageW(pszPackageName);
758
759 TRACE("%s %p\n", debugstr_w(pszPackageName), ppPackageInfo);
760 if (package)
761 {
762 size_t bytesNeeded = sizeof(SecPkgInfoW);
763 int nameLen = 0, commentLen = 0;
764
765 if (package->infoW.Name)
766 {
767 nameLen = lstrlenW(package->infoW.Name) + 1;
768 bytesNeeded += nameLen * sizeof(WCHAR);
769 }
770 if (package->infoW.Comment)
771 {
772 commentLen = lstrlenW(package->infoW.Comment) + 1;
773 bytesNeeded += commentLen * sizeof(WCHAR);
774 }
775 *ppPackageInfo = HeapAlloc(GetProcessHeap(), 0, bytesNeeded);
776 if (*ppPackageInfo)
777 {
778 PWSTR nextString = (PWSTR)((PBYTE)*ppPackageInfo +
779 sizeof(SecPkgInfoW));
780
781 **ppPackageInfo = package->infoW;
782 if (package->infoW.Name)
783 {
784 (*ppPackageInfo)->Name = nextString;
785 lstrcpynW(nextString, package->infoW.Name, nameLen);
786 nextString += nameLen;
787 }
788 else
789 (*ppPackageInfo)->Name = NULL;
790 if (package->infoW.Comment)
791 {
792 (*ppPackageInfo)->Comment = nextString;
793 lstrcpynW(nextString, package->infoW.Comment, commentLen);
794 nextString += commentLen;
795 }
796 else
797 (*ppPackageInfo)->Comment = NULL;
798 ret = SEC_E_OK;
799 }
800 else
801 ret = SEC_E_INSUFFICIENT_MEMORY;
802 }
803 else
804 ret = SEC_E_SECPKG_NOT_FOUND;
805 return ret;
806}
807
808/***********************************************************************
809 * ExportSecurityContext (SECUR32.@)
810 */
811SECURITY_STATUS WINAPI ExportSecurityContext(PCtxtHandle phContext,
812 ULONG fFlags, PSecBuffer pPackedContext, void **pToken)
813{
814 SECURITY_STATUS ret;
815
816 TRACE("%p %d %p %p\n", phContext, fFlags, pPackedContext, pToken);
817 if (phContext)
818 {
819 SecurePackage *package = (SecurePackage *)phContext->dwUpper;
820 PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
821
822 if (package && package->provider)
823 {
824 if (package->provider->fnTableW.ExportSecurityContext)
825 ret = package->provider->fnTableW.ExportSecurityContext(
826 ctxt, fFlags, pPackedContext, pToken);
827 else
828 ret = SEC_E_UNSUPPORTED_FUNCTION;
829 }
830 else
831 ret = SEC_E_INVALID_HANDLE;
832 }
833 else
834 ret = SEC_E_INVALID_HANDLE;
835 return ret;
836}
837
838/***********************************************************************
839 * ImportSecurityContextA (SECUR32.@)
840 */
841SECURITY_STATUS WINAPI ImportSecurityContextA(SEC_CHAR *pszPackage,
842 PSecBuffer pPackedContext, void *Token, PCtxtHandle phContext)
843{
844 SECURITY_STATUS ret;
845 SecurePackage *package = SECUR32_findPackageA(pszPackage);
846
847 TRACE("%s %p %p %p\n", debugstr_a(pszPackage), pPackedContext, Token,
848 phContext);
849 if (package && package->provider)
850 {
851 if (package->provider->fnTableA.ImportSecurityContextA)
852 {
853 CtxtHandle myCtxt;
854
855 ret = package->provider->fnTableA.ImportSecurityContextA(
856 pszPackage, pPackedContext, Token, &myCtxt);
857 if (ret == SEC_E_OK)
858 {
859 ret = SECUR32_makeSecHandle(phContext, package, &myCtxt);
860 if (ret != SEC_E_OK)
861 package->provider->fnTableW.DeleteSecurityContext(&myCtxt);
862 }
863 }
864 else
865 ret = SEC_E_UNSUPPORTED_FUNCTION;
866 }
867 else
868 ret = SEC_E_SECPKG_NOT_FOUND;
869 return ret;
870
871}
872
873/***********************************************************************
874 * ImportSecurityContextW (SECUR32.@)
875 */
876SECURITY_STATUS WINAPI ImportSecurityContextW(SEC_WCHAR *pszPackage,
877 PSecBuffer pPackedContext, void *Token, PCtxtHandle phContext)
878{
879 SECURITY_STATUS ret;
880 SecurePackage *package = SECUR32_findPackageW(pszPackage);
881
882 TRACE("%s %p %p %p\n", debugstr_w(pszPackage), pPackedContext, Token,
883 phContext);
884 if (package && package->provider)
885 {
886 if (package->provider->fnTableW.ImportSecurityContextW)
887 {
888 CtxtHandle myCtxt;
889
890 ret = package->provider->fnTableW.ImportSecurityContextW(
891 pszPackage, pPackedContext, Token, &myCtxt);
892 if (ret == SEC_E_OK)
893 {
894 ret = SECUR32_makeSecHandle(phContext, package, &myCtxt);
895 if (ret != SEC_E_OK)
896 package->provider->fnTableW.DeleteSecurityContext(&myCtxt);
897 }
898 }
899 else
900 ret = SEC_E_UNSUPPORTED_FUNCTION;
901 }
902 else
903 ret = SEC_E_SECPKG_NOT_FOUND;
904 return ret;
905}
906
907/***********************************************************************
908 * AddCredentialsA (SECUR32.@)
909 */
910SECURITY_STATUS WINAPI AddCredentialsA(PCredHandle hCredentials,
911 SEC_CHAR *pszPrincipal, SEC_CHAR *pszPackage, ULONG fCredentialUse,
912 void *pAuthData, SEC_GET_KEY_FN pGetKeyFn, void *pvGetKeyArgument,
913 PTimeStamp ptsExpiry)
914{
915 SECURITY_STATUS ret;
916
917 TRACE("%p %s %s %d %p %p %p %p\n", hCredentials, debugstr_a(pszPrincipal),
918 debugstr_a(pszPackage), fCredentialUse, pAuthData, pGetKeyFn,
919 pvGetKeyArgument, ptsExpiry);
920 if (hCredentials)
921 {
922 SecurePackage *package = (SecurePackage *)hCredentials->dwUpper;
923 PCredHandle cred = (PCtxtHandle)hCredentials->dwLower;
924
925 if (package && package->provider)
926 {
927 if (package->provider->fnTableA.AddCredentialsA)
928 ret = package->provider->fnTableA.AddCredentialsA(
929 cred, pszPrincipal, pszPackage, fCredentialUse, pAuthData,
930 pGetKeyFn, pvGetKeyArgument, ptsExpiry);
931 else
932 ret = SEC_E_UNSUPPORTED_FUNCTION;
933 }
934 else
935 ret = SEC_E_INVALID_HANDLE;
936 }
937 else
938 ret = SEC_E_INVALID_HANDLE;
939 return ret;
940}
941
942/***********************************************************************
943 * AddCredentialsW (SECUR32.@)
944 */
945SECURITY_STATUS WINAPI AddCredentialsW(PCredHandle hCredentials,
946 SEC_WCHAR *pszPrincipal, SEC_WCHAR *pszPackage, ULONG fCredentialUse,
947 void *pAuthData, SEC_GET_KEY_FN pGetKeyFn, void *pvGetKeyArgument,
948 PTimeStamp ptsExpiry)
949{
950 SECURITY_STATUS ret;
951
952 TRACE("%p %s %s %d %p %p %p %p\n", hCredentials, debugstr_w(pszPrincipal),
953 debugstr_w(pszPackage), fCredentialUse, pAuthData, pGetKeyFn,
954 pvGetKeyArgument, ptsExpiry);
955 if (hCredentials)
956 {
957 SecurePackage *package = (SecurePackage *)hCredentials->dwUpper;
958 PCredHandle cred = (PCtxtHandle)hCredentials->dwLower;
959
960 if (package && package->provider)
961 {
962 if (package->provider->fnTableW.AddCredentialsW)
963 ret = package->provider->fnTableW.AddCredentialsW(
964 cred, pszPrincipal, pszPackage, fCredentialUse, pAuthData,
965 pGetKeyFn, pvGetKeyArgument, ptsExpiry);
966 else
967 ret = SEC_E_UNSUPPORTED_FUNCTION;
968 }
969 else
970 ret = SEC_E_INVALID_HANDLE;
971 }
972 else
973 ret = SEC_E_INVALID_HANDLE;
974 return ret;
975}
976
977/***********************************************************************
978 * QuerySecurityContextToken (SECUR32.@)
979 */
980SECURITY_STATUS WINAPI QuerySecurityContextToken(PCtxtHandle phContext,
981 HANDLE *phToken)
982{
983 SECURITY_STATUS ret;
984
985 TRACE("%p %p\n", phContext, phToken);
986 if (phContext)
987 {
988 SecurePackage *package = (SecurePackage *)phContext->dwUpper;
989 PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
990
991 if (package && package->provider)
992 {
993 if (package->provider->fnTableW.QuerySecurityContextToken)
994 ret = package->provider->fnTableW.QuerySecurityContextToken(
995 ctxt, phToken);
996 else
997 ret = SEC_E_UNSUPPORTED_FUNCTION;
998 }
999 else
1000 ret = SEC_E_INVALID_HANDLE;
1001 }
1002 else
1003 ret = SEC_E_INVALID_HANDLE;
1004 return ret;
1005}
1006
1007/***********************************************************************
1008 * EncryptMessage (SECUR32.@)
1009 */
1010SECURITY_STATUS WINAPI EncryptMessage(PCtxtHandle phContext, ULONG fQOP,
1011 PSecBufferDesc pMessage, ULONG MessageSeqNo)
1012{
1013 SECURITY_STATUS ret;
1014
1015 TRACE("%p %d %p %d\n", phContext, fQOP, pMessage, MessageSeqNo);
1016 if (phContext)
1017 {
1018 SecurePackage *package = (SecurePackage *)phContext->dwUpper;
1019 PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
1020
1021 if (package && package->provider)
1022 {
1023 if (package->provider->fnTableW.EncryptMessage)
1024 ret = package->provider->fnTableW.EncryptMessage(
1025 ctxt, fQOP, pMessage, MessageSeqNo);
1026 else
1027 ret = SEC_E_UNSUPPORTED_FUNCTION;
1028 }
1029 else
1030 ret = SEC_E_INVALID_HANDLE;
1031 }
1032 else
1033 ret = SEC_E_INVALID_HANDLE;
1034 return ret;
1035}
1036
1037/***********************************************************************
1038 * DecryptMessage (SECUR32.@)
1039 */
1040SECURITY_STATUS WINAPI DecryptMessage(PCtxtHandle phContext,
1041 PSecBufferDesc pMessage, ULONG MessageSeqNo, PULONG pfQOP)
1042{
1043 SECURITY_STATUS ret;
1044
1045 TRACE("%p %p %d %p\n", phContext, pMessage, MessageSeqNo, pfQOP);
1046 if (phContext)
1047 {
1048 SecurePackage *package = (SecurePackage *)phContext->dwUpper;
1049 PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
1050
1051 if (package && package->provider)
1052 {
1053 if (package->provider->fnTableW.DecryptMessage)
1054 ret = package->provider->fnTableW.DecryptMessage(
1055 ctxt, pMessage, MessageSeqNo, pfQOP);
1056 else
1057 ret = SEC_E_UNSUPPORTED_FUNCTION;
1058 }
1059 else
1060 ret = SEC_E_INVALID_HANDLE;
1061 }
1062 else
1063 ret = SEC_E_INVALID_HANDLE;
1064 return ret;
1065}
1066
1067/***********************************************************************
1068 * SetContextAttributesA (SECUR32.@)
1069 */
1070SECURITY_STATUS WINAPI SetContextAttributesA(PCtxtHandle phContext,
1071 ULONG ulAttribute, void *pBuffer, ULONG cbBuffer)
1072{
1073 SECURITY_STATUS ret;
1074
1075 TRACE("%p %d %p %d\n", phContext, ulAttribute, pBuffer, cbBuffer);
1076 if (phContext)
1077 {
1078 SecurePackage *package = (SecurePackage *)phContext->dwUpper;
1079 PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
1080
1081 if (package && package->provider)
1082 {
1083 if (package->provider->fnTableA.SetContextAttributesA)
1084 ret = package->provider->fnTableA.SetContextAttributesA(
1085 ctxt, ulAttribute, pBuffer, cbBuffer);
1086 else
1087 ret = SEC_E_UNSUPPORTED_FUNCTION;
1088 }
1089 else
1090 ret = SEC_E_INVALID_HANDLE;
1091 }
1092 else
1093 ret = SEC_E_INVALID_HANDLE;
1094 return ret;
1095}
1096
1097/***********************************************************************
1098 * SetContextAttributesW (SECUR32.@)
1099 */
1100SECURITY_STATUS WINAPI SetContextAttributesW(PCtxtHandle phContext,
1101 ULONG ulAttribute, void *pBuffer, ULONG cbBuffer)
1102{
1103 SECURITY_STATUS ret;
1104
1105 TRACE("%p %d %p %d\n", phContext, ulAttribute, pBuffer, cbBuffer);
1106 if (phContext)
1107 {
1108 SecurePackage *package = (SecurePackage *)phContext->dwUpper;
1109 PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
1110
1111 if (package && package->provider)
1112 {
1113 if (package->provider->fnTableW.SetContextAttributesW)
1114 ret = package->provider->fnTableW.SetContextAttributesW(
1115 ctxt, ulAttribute, pBuffer, cbBuffer);
1116 else
1117 ret = SEC_E_UNSUPPORTED_FUNCTION;
1118 }
1119 else
1120 ret = SEC_E_INVALID_HANDLE;
1121 }
1122 else
1123 ret = SEC_E_INVALID_HANDLE;
1124 return ret;
1125}
Note: See TracBrowser for help on using the repository browser.