1 // Licensed under the Apache License, Version 2.0
2 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
4 // All files in the project carrying such notice may not be copied, modified, or distributed
5 // except according to those terms.
6 //! Authentication API Prototypes and Definitions
7 use shared::minwindef::{
8     BOOL, DWORD, FILETIME, LPBYTE, LPCVOID, LPDWORD, LPVOID, PBOOL, PBYTE, UCHAR, ULONG
9 };
10 use shared::windef::{HBITMAP, HWND};
11 use um::sspi::PCtxtHandle;
12 use um::winnt::{CHAR, LPCSTR, LPCWSTR, LPSTR, LPWSTR, PCSTR, PCWSTR, PSTR, PVOID, PWSTR, WCHAR};
13 // STATUS_*
14 pub const NERR_BASE: DWORD = 2100;
15 pub const NERR_PasswordExpired: DWORD = NERR_BASE + 142;
16 pub const CRED_MAX_STRING_LENGTH: DWORD = 256;
17 pub const CRED_MAX_USERNAME_LENGTH: DWORD = 256 + 1 + 256;
18 pub const CRED_MAX_GENERIC_TARGET_NAME_LENGTH: DWORD = 32767;
19 pub const CRED_MAX_DOMAIN_TARGET_NAME_LENGTH: DWORD = 256 + 1 + 80;
20 pub const CRED_MAX_TARGETNAME_NAMESPACE_LENGTH: DWORD = 256;
21 pub const CRED_MAX_TARGETNAME_ATTRIBUTE_LENGTH: DWORD = 256;
22 pub const CRED_MAX_VALUE_SIZE: DWORD = 256;
23 pub const CRED_MAX_ATTRIBUTES: DWORD = 64;
24 STRUCT!{struct CREDENTIAL_ATTRIBUTEA {
25     Keyword: LPSTR,
26     Flags: DWORD,
27     ValueSize: DWORD,
28     Value: LPBYTE,
29 }}
30 pub type PCREDENTIAL_ATTRIBUTEA = *mut CREDENTIAL_ATTRIBUTEA;
31 STRUCT!{struct CREDENTIAL_ATTRIBUTEW {
32     Keyword: LPWSTR,
33     Flags: DWORD,
34     ValueSize: DWORD,
35     Value: LPBYTE,
36 }}
37 pub type PCREDENTIAL_ATTRIBUTEW = *mut CREDENTIAL_ATTRIBUTEW;
38 pub const CRED_LOGON_TYPES_MASK: DWORD = 0xF000;
39 pub const CRED_FLAGS_PASSWORD_FOR_CERT: DWORD = 0x0001;
40 pub const CRED_FLAGS_PROMPT_NOW: DWORD = 0x0002;
41 pub const CRED_FLAGS_USERNAME_TARGET: DWORD = 0x0004;
42 pub const CRED_FLAGS_OWF_CRED_BLOB: DWORD = 0x0008;
43 pub const CRED_FLAGS_REQUIRE_CONFIRMATION: DWORD = 0x0010;
44 pub const CRED_FLAGS_WILDCARD_MATCH: DWORD = 0x0020;
45 pub const CRED_FLAGS_VALID_FLAGS: DWORD = 0xF03F;
46 pub const CRED_FLAGS_VALID_INPUT_FLAGS: DWORD = 0xF01F;
47 pub const CRED_TYPE_GENERIC: DWORD = 1;
48 pub const CRED_TYPE_DOMAIN_PASSWORD: DWORD = 2;
49 pub const CRED_TYPE_DOMAIN_CERTIFICATE: DWORD = 3;
50 pub const CRED_TYPE_DOMAIN_VISIBLE_PASSWORD: DWORD = 4;
51 pub const CRED_TYPE_GENERIC_CERTIFICATE: DWORD = 5;
52 pub const CRED_TYPE_DOMAIN_EXTENDED: DWORD = 6;
53 pub const CRED_TYPE_MAXIMUM: DWORD = 7;
54 pub const CRED_TYPE_MAXIMUM_EX: DWORD = CRED_TYPE_MAXIMUM + 1000;
55 pub const CRED_MAX_CREDENTIAL_BLOB_SIZE: DWORD = 5 * 512;
56 pub const CRED_PERSIST_NONE: DWORD = 0;
57 pub const CRED_PERSIST_SESSION: DWORD = 1;
58 pub const CRED_PERSIST_LOCAL_MACHINE: DWORD = 2;
59 pub const CRED_PERSIST_ENTERPRISE: DWORD = 3;
60 STRUCT!{struct CREDENTIALA {
61     Flags: DWORD,
62     Type: DWORD,
63     TargetName: LPSTR,
64     Comment: LPSTR,
65     LastWritten: FILETIME,
66     CredentialBlobSize: DWORD,
67     CredentialBlob: LPBYTE,
68     Persist: DWORD,
69     AttributeCount: DWORD,
70     Attributes: PCREDENTIAL_ATTRIBUTEA,
71     TargetAlias: LPSTR,
72     UserName: LPSTR,
73 }}
74 pub type PCREDENTIALA = *mut CREDENTIALA;
75 STRUCT!{struct CREDENTIALW {
76     Flags: DWORD,
77     Type: DWORD,
78     TargetName: LPWSTR,
79     Comment: LPWSTR,
80     LastWritten: FILETIME,
81     CredentialBlobSize: DWORD,
82     CredentialBlob: LPBYTE,
83     Persist: DWORD,
84     AttributeCount: DWORD,
85     Attributes: PCREDENTIAL_ATTRIBUTEW,
86     TargetAlias: LPWSTR,
87     UserName: LPWSTR,
88 }}
89 pub type PCREDENTIALW = *mut CREDENTIALW;
90 pub const CRED_TI_SERVER_FORMAT_UNKNOWN: ULONG = 0x0001;
91 pub const CRED_TI_DOMAIN_FORMAT_UNKNOWN: ULONG = 0x0002;
92 pub const CRED_TI_ONLY_PASSWORD_REQUIRED: ULONG = 0x0004;
93 pub const CRED_TI_USERNAME_TARGET: ULONG = 0x0008;
94 pub const CRED_TI_CREATE_EXPLICIT_CRED: ULONG = 0x0010;
95 pub const CRED_TI_WORKGROUP_MEMBER: ULONG = 0x0020;
96 pub const CRED_TI_VALID_FLAGS: ULONG = 0xF07F;
97 STRUCT!{struct CREDENTIAL_TARGET_INFORMATIONA {
98     TargetName: LPSTR,
99     NetbiosServerName: LPSTR,
100     DnsServerName: LPSTR,
101     NetbiosDomainName: LPSTR,
102     DnsDomainName: LPSTR,
103     DnsTreeName: LPSTR,
104     PackageName: LPSTR,
105     Flags: ULONG,
106     CredTypeCount: DWORD,
107     CredTypes: LPDWORD,
108 }}
109 pub type PCREDENTIAL_TARGET_INFORMATIONA = *mut CREDENTIAL_TARGET_INFORMATIONA;
110 STRUCT!{struct CREDENTIAL_TARGET_INFORMATIONW {
111     TargetName: LPWSTR,
112     NetbiosServerName: LPWSTR,
113     DnsServerName: LPWSTR,
114     NetbiosDomainName: LPWSTR,
115     DnsDomainName: LPWSTR,
116     DnsTreeName: LPWSTR,
117     PackageName: LPWSTR,
118     Flags: ULONG,
119     CredTypeCount: DWORD,
120     CredTypes: LPDWORD,
121 }}
122 pub type PCREDENTIAL_TARGET_INFORMATIONW = *mut CREDENTIAL_TARGET_INFORMATIONW;
123 pub const CERT_HASH_LENGTH: usize = 20;
124 STRUCT!{struct CERT_CREDENTIAL_INFO {
125     cbSize: ULONG,
126     rgbHashOfCert: [UCHAR; CERT_HASH_LENGTH],
127 }}
128 pub type PCERT_CREDENTIAL_INFO = *mut CERT_CREDENTIAL_INFO;
129 STRUCT!{struct USERNAME_TARGET_CREDENTIAL_INFO {
130     UserName: LPWSTR,
131 }}
132 pub type PUSERNAME_TARGET_CREDENTIAL_INFO = *mut USERNAME_TARGET_CREDENTIAL_INFO;
133 STRUCT!{struct BINARY_BLOB_CREDENTIAL_INFO {
134     cbBlob: ULONG,
135     pbBlob: LPBYTE,
136 }}
137 pub type PBINARY_BLOB_CREDENTIAL_INFO = *mut BINARY_BLOB_CREDENTIAL_INFO;
138 ENUM!{enum CRED_MARSHAL_TYPE {
139     CertCredential = 1,
140     UsernameTargetCredential,
141     BinaryBlobCredential,
142     UsernameForPackedCredentials,
143 }}
144 pub type PCRED_MARSHAL_TYPE = *mut CRED_MARSHAL_TYPE;
145 ENUM!{enum CRED_PROTECTION_TYPE {
146     CredUnprotected,
147     CredUserProtection,
148     CredTrustedProtection,
149 }}
150 pub type PCRED_PROTECTION_TYPE = *mut CRED_PROTECTION_TYPE;
151 pub const CRED_PACK_PROTECTED_CREDENTIALS: DWORD = 0x1;
152 pub const CRED_PACK_WOW_BUFFER: DWORD = 0x2;
153 pub const CRED_PACK_GENERIC_CREDENTIALS: DWORD = 0x4;
154 pub const CRED_PACK_ID_PROVIDER_CREDENTIALS: DWORD = 0x8;
155 STRUCT!{struct CREDUI_INFOA {
156     cbSize: DWORD,
157     hwndParent: HWND,
158     pszMessageText: PCSTR,
159     pszCaptionText: PCSTR,
160     hbmBanner: HBITMAP,
161 }}
162 pub type PCREDUI_INFOA = *mut CREDUI_INFOA;
163 STRUCT!{struct CREDUI_INFOW {
164     cbSize: DWORD,
165     hwndParent: HWND,
166     pszMessageText: PCWSTR,
167     pszCaptionText: PCWSTR,
168     hbmBanner: HBITMAP,
169 }}
170 pub type PCREDUI_INFOW = *mut CREDUI_INFOW;
171 pub const CREDUI_MAX_MESSAGE_LENGTH: DWORD = 1024;
172 pub const CREDUI_MAX_CAPTION_LENGTH: DWORD = 128;
173 pub const CREDUI_MAX_GENERIC_TARGET_LENGTH: DWORD = CRED_MAX_GENERIC_TARGET_NAME_LENGTH;
174 pub const CREDUI_MAX_DOMAIN_TARGET_LENGTH: DWORD = CRED_MAX_DOMAIN_TARGET_NAME_LENGTH;
175 pub const CREDUI_MAX_USERNAME_LENGTH: DWORD = CRED_MAX_USERNAME_LENGTH;
176 pub const CREDUI_MAX_PASSWORD_LENGTH: DWORD = 512 / 2;
177 pub const CREDUI_FLAGS_INCORRECT_PASSWORD: DWORD = 0x00001;
178 pub const CREDUI_FLAGS_DO_NOT_PERSIST: DWORD = 0x00002;
179 pub const CREDUI_FLAGS_REQUEST_ADMINISTRATOR: DWORD = 0x00004;
180 pub const CREDUI_FLAGS_EXCLUDE_CERTIFICATES: DWORD = 0x00008;
181 pub const CREDUI_FLAGS_REQUIRE_CERTIFICATE: DWORD = 0x00010;
182 pub const CREDUI_FLAGS_SHOW_SAVE_CHECK_BOX: DWORD = 0x00040;
183 pub const CREDUI_FLAGS_ALWAYS_SHOW_UI: DWORD = 0x00080;
184 pub const CREDUI_FLAGS_REQUIRE_SMARTCARD: DWORD = 0x00100;
185 pub const CREDUI_FLAGS_PASSWORD_ONLY_OK: DWORD = 0x00200;
186 pub const CREDUI_FLAGS_VALIDATE_USERNAME: DWORD = 0x00400;
187 pub const CREDUI_FLAGS_COMPLETE_USERNAME: DWORD = 0x00800;
188 pub const CREDUI_FLAGS_PERSIST: DWORD = 0x01000;
189 pub const CREDUI_FLAGS_SERVER_CREDENTIAL: DWORD = 0x04000;
190 pub const CREDUI_FLAGS_EXPECT_CONFIRMATION: DWORD = 0x20000;
191 pub const CREDUI_FLAGS_GENERIC_CREDENTIALS: DWORD = 0x40000;
192 pub const CREDUI_FLAGS_USERNAME_TARGET_CREDENTIALS: DWORD = 0x80000;
193 pub const CREDUI_FLAGS_KEEP_USERNAME: DWORD = 0x100000;
194 pub const CREDUI_FLAGS_PROMPT_VALID: DWORD = CREDUI_FLAGS_INCORRECT_PASSWORD
195     | CREDUI_FLAGS_DO_NOT_PERSIST | CREDUI_FLAGS_REQUEST_ADMINISTRATOR
196     | CREDUI_FLAGS_EXCLUDE_CERTIFICATES | CREDUI_FLAGS_REQUIRE_CERTIFICATE
197     | CREDUI_FLAGS_SHOW_SAVE_CHECK_BOX | CREDUI_FLAGS_ALWAYS_SHOW_UI
198     | CREDUI_FLAGS_REQUIRE_SMARTCARD | CREDUI_FLAGS_PASSWORD_ONLY_OK
199     | CREDUI_FLAGS_VALIDATE_USERNAME | CREDUI_FLAGS_COMPLETE_USERNAME | CREDUI_FLAGS_PERSIST
200     | CREDUI_FLAGS_SERVER_CREDENTIAL | CREDUI_FLAGS_EXPECT_CONFIRMATION
201     | CREDUI_FLAGS_GENERIC_CREDENTIALS | CREDUI_FLAGS_USERNAME_TARGET_CREDENTIALS
202     | CREDUI_FLAGS_KEEP_USERNAME;
203 pub const CREDUIWIN_GENERIC: DWORD = 0x00000001;
204 pub const CREDUIWIN_CHECKBOX: DWORD = 0x00000002;
205 pub const CREDUIWIN_AUTHPACKAGE_ONLY: DWORD = 0x00000010;
206 pub const CREDUIWIN_IN_CRED_ONLY: DWORD = 0x00000020;
207 pub const CREDUIWIN_ENUMERATE_ADMINS: DWORD = 0x00000100;
208 pub const CREDUIWIN_ENUMERATE_CURRENT_USER: DWORD = 0x00000200;
209 pub const CREDUIWIN_SECURE_PROMPT: DWORD = 0x00001000;
210 pub const CREDUIWIN_PREPROMPTING: DWORD = 0x00002000;
211 pub const CREDUIWIN_PACK_32_WOW: DWORD = 0x10000000;
212 pub const CREDUIWIN_VALID_FLAGS: DWORD = CREDUIWIN_GENERIC | CREDUIWIN_CHECKBOX
213     | CREDUIWIN_AUTHPACKAGE_ONLY | CREDUIWIN_IN_CRED_ONLY | CREDUIWIN_ENUMERATE_ADMINS
214     | CREDUIWIN_ENUMERATE_CURRENT_USER | CREDUIWIN_SECURE_PROMPT | CREDUIWIN_PREPROMPTING
215     | CREDUIWIN_PACK_32_WOW;
216 pub const CRED_PRESERVE_CREDENTIAL_BLOB: DWORD = 0x1;
217 extern "system" {
CredWriteW( Credential: PCREDENTIALW, Flags: DWORD, ) -> BOOL218     pub fn CredWriteW(
219         Credential: PCREDENTIALW,
220         Flags: DWORD,
221     ) -> BOOL;
CredWriteA( Credential: PCREDENTIALA, Flags: DWORD, ) -> BOOL222     pub fn CredWriteA(
223         Credential: PCREDENTIALA,
224         Flags: DWORD,
225     ) -> BOOL;
CredReadW( TargetName: LPCWSTR, Type: DWORD, Flags: DWORD, Credential: *mut PCREDENTIALW, ) -> BOOL226     pub fn CredReadW(
227         TargetName: LPCWSTR,
228         Type: DWORD,
229         Flags: DWORD,
230         Credential: *mut PCREDENTIALW,
231     ) -> BOOL;
CredReadA( TargetName: LPCSTR, Type: DWORD, Flags: DWORD, Credential: *mut PCREDENTIALA, ) -> BOOL232     pub fn CredReadA(
233         TargetName: LPCSTR,
234         Type: DWORD,
235         Flags: DWORD,
236         Credential: *mut PCREDENTIALA,
237     ) -> BOOL;
238 }
239 pub const CRED_ENUMERATE_ALL_CREDENTIALS: DWORD = 0x1;
240 extern "system" {
CredEnumerateW( Filter: LPCWSTR, Flags: DWORD, Count: *mut DWORD, Credential: *mut *mut PCREDENTIALW, ) -> BOOL241     pub fn CredEnumerateW(
242         Filter: LPCWSTR,
243         Flags: DWORD,
244         Count: *mut DWORD,
245         Credential: *mut *mut PCREDENTIALW,
246     ) -> BOOL;
CredEnumerateA( Filter: LPCSTR, Flags: DWORD, Count: *mut DWORD, Credential: *mut *mut PCREDENTIALA, ) -> BOOL247     pub fn CredEnumerateA(
248         Filter: LPCSTR,
249         Flags: DWORD,
250         Count: *mut DWORD,
251         Credential: *mut *mut PCREDENTIALA,
252     ) -> BOOL;
CredWriteDomainCredentialsW( TargetInfo: PCREDENTIAL_TARGET_INFORMATIONW, Credential: PCREDENTIALW, Flags: DWORD, ) -> BOOL253     pub fn CredWriteDomainCredentialsW(
254         TargetInfo: PCREDENTIAL_TARGET_INFORMATIONW,
255         Credential: PCREDENTIALW,
256         Flags: DWORD,
257     ) -> BOOL;
CredWriteDomainCredentialsA( TargetInfo: PCREDENTIAL_TARGET_INFORMATIONA, Credential: PCREDENTIALA, Flags: DWORD, ) -> BOOL258     pub fn CredWriteDomainCredentialsA(
259         TargetInfo: PCREDENTIAL_TARGET_INFORMATIONA,
260         Credential: PCREDENTIALA,
261         Flags: DWORD,
262     ) -> BOOL;
263 }
264 pub const CRED_CACHE_TARGET_INFORMATION: DWORD = 0x1;
265 extern "system" {
CredReadDomainCredentialsW( TargetInfo: PCREDENTIAL_TARGET_INFORMATIONW, Flags: DWORD, Count: *mut DWORD, Credential: *mut *mut PCREDENTIALW, ) -> BOOL266     pub fn CredReadDomainCredentialsW(
267         TargetInfo: PCREDENTIAL_TARGET_INFORMATIONW,
268         Flags: DWORD,
269         Count: *mut DWORD,
270         Credential: *mut *mut PCREDENTIALW,
271     ) -> BOOL;
CredReadDomainCredentialsA( TargetInfo: PCREDENTIAL_TARGET_INFORMATIONA, Flags: DWORD, Count: *mut DWORD, Credential: *mut *mut PCREDENTIALA, ) -> BOOL272     pub fn CredReadDomainCredentialsA(
273         TargetInfo: PCREDENTIAL_TARGET_INFORMATIONA,
274         Flags: DWORD,
275         Count: *mut DWORD,
276         Credential: *mut *mut PCREDENTIALA,
277     ) -> BOOL;
CredDeleteW( TargetName: LPCWSTR, Type: DWORD, Flags: DWORD, ) -> BOOL278     pub fn CredDeleteW(
279         TargetName: LPCWSTR,
280         Type: DWORD,
281         Flags: DWORD,
282     ) -> BOOL;
CredDeleteA( TargetName: LPCSTR, Type: DWORD, Flags: DWORD, ) -> BOOL283     pub fn CredDeleteA(
284         TargetName: LPCSTR,
285         Type: DWORD,
286         Flags: DWORD,
287     ) -> BOOL;
CredRenameW( OldTargetName: LPCWSTR, NewTargetName: LPCWSTR, Type: DWORD, Flags: DWORD, ) -> BOOL288     pub fn CredRenameW(
289         OldTargetName: LPCWSTR,
290         NewTargetName: LPCWSTR,
291         Type: DWORD,
292         Flags: DWORD,
293     ) -> BOOL;
CredRenameA( OldTargetName: LPCSTR, NewTargetName: LPCSTR, Type: DWORD, Flags: DWORD, ) -> BOOL294     pub fn CredRenameA(
295         OldTargetName: LPCSTR,
296         NewTargetName: LPCSTR,
297         Type: DWORD,
298         Flags: DWORD,
299     ) -> BOOL;
300 }
301 pub const CRED_ALLOW_NAME_RESOLUTION: DWORD = 0x1;
302 extern "system" {
CredGetTargetInfoW( TargetName: LPCWSTR, Flags: DWORD, TargetInfo: *mut PCREDENTIAL_TARGET_INFORMATIONW, ) -> BOOL303     pub fn CredGetTargetInfoW(
304         TargetName: LPCWSTR,
305         Flags: DWORD,
306         TargetInfo: *mut PCREDENTIAL_TARGET_INFORMATIONW,
307     ) -> BOOL;
CredGetTargetInfoA( TargetName: LPCSTR, Flags: DWORD, TargetInfo: *mut PCREDENTIAL_TARGET_INFORMATIONA, ) -> BOOL308     pub fn CredGetTargetInfoA(
309         TargetName: LPCSTR,
310         Flags: DWORD,
311         TargetInfo: *mut PCREDENTIAL_TARGET_INFORMATIONA,
312     ) -> BOOL;
CredMarshalCredentialW( CredType: CRED_MARSHAL_TYPE, Credential: PVOID, MarhaledCredential: *mut LPWSTR, ) -> BOOL313     pub fn CredMarshalCredentialW(
314         CredType: CRED_MARSHAL_TYPE,
315         Credential: PVOID,
316         MarhaledCredential: *mut LPWSTR,
317     ) -> BOOL;
CredMarshalCredentialA( CredType: CRED_MARSHAL_TYPE, Credential: PVOID, MarhaledCredential: *mut LPSTR, ) -> BOOL318     pub fn CredMarshalCredentialA(
319         CredType: CRED_MARSHAL_TYPE,
320         Credential: PVOID,
321         MarhaledCredential: *mut LPSTR,
322     ) -> BOOL;
CredUnmarshalCredentialW( MarshaledCredential: LPCWSTR, CredType: PCRED_MARSHAL_TYPE, Credential: *mut PVOID, ) -> BOOL323     pub fn CredUnmarshalCredentialW(
324         MarshaledCredential: LPCWSTR,
325         CredType: PCRED_MARSHAL_TYPE,
326         Credential: *mut PVOID,
327     ) -> BOOL;
CredUnmarshalCredentialA( MarshaledCredential: LPCSTR, CredType: PCRED_MARSHAL_TYPE, Credential: *mut PVOID, ) -> BOOL328     pub fn CredUnmarshalCredentialA(
329         MarshaledCredential: LPCSTR,
330         CredType: PCRED_MARSHAL_TYPE,
331         Credential: *mut PVOID,
332     ) -> BOOL;
CredIsMarshaledCredentialW( MarshaledCredential: LPCWSTR, ) -> BOOL333     pub fn CredIsMarshaledCredentialW(
334         MarshaledCredential: LPCWSTR,
335     ) -> BOOL;
CredIsMarshaledCredentialA( MarshaledCredential: LPCSTR, ) -> BOOL336     pub fn CredIsMarshaledCredentialA(
337         MarshaledCredential: LPCSTR,
338     ) -> BOOL;
CredUnPackAuthenticationBufferW( dwFlags: DWORD, pAuthBuffer: PVOID, cbAuthBuffer: DWORD, pszUserName: LPWSTR, pcchlMaxUserName: *mut DWORD, pszDomainName: LPWSTR, pcchMaxDomainName: *mut DWORD, pszPassword: LPWSTR, pcchMaxPassword: *mut DWORD, ) -> BOOL339     pub fn CredUnPackAuthenticationBufferW(
340         dwFlags: DWORD,
341         pAuthBuffer: PVOID,
342         cbAuthBuffer: DWORD,
343         pszUserName: LPWSTR,
344         pcchlMaxUserName: *mut DWORD,
345         pszDomainName: LPWSTR,
346         pcchMaxDomainName: *mut DWORD,
347         pszPassword: LPWSTR,
348         pcchMaxPassword: *mut DWORD,
349     ) -> BOOL;
CredUnPackAuthenticationBufferA( dwFlags: DWORD, pAuthBuffer: PVOID, cbAuthBuffer: DWORD, pszUserName: LPSTR, pcchlMaxUserName: *mut DWORD, pszDomainName: LPSTR, pcchMaxDomainName: *mut DWORD, pszPassword: LPSTR, pcchMaxPassword: *mut DWORD, ) -> BOOL350     pub fn CredUnPackAuthenticationBufferA(
351         dwFlags: DWORD,
352         pAuthBuffer: PVOID,
353         cbAuthBuffer: DWORD,
354         pszUserName: LPSTR,
355         pcchlMaxUserName: *mut DWORD,
356         pszDomainName: LPSTR,
357         pcchMaxDomainName: *mut DWORD,
358         pszPassword: LPSTR,
359         pcchMaxPassword: *mut DWORD,
360     ) -> BOOL;
CredPackAuthenticationBufferW( dwFlags: DWORD, pszUserName: LPWSTR, pszPassword: LPWSTR, pPackedCredentials: PBYTE, pcbPackedCredentials: *mut DWORD, ) -> BOOL361     pub fn CredPackAuthenticationBufferW(
362         dwFlags: DWORD,
363         pszUserName: LPWSTR,
364         pszPassword: LPWSTR,
365         pPackedCredentials: PBYTE,
366         pcbPackedCredentials: *mut DWORD,
367     ) -> BOOL;
CredPackAuthenticationBufferA( dwFlags: DWORD, pszUserName: LPSTR, pszPassword: LPSTR, pPackedCredentials: PBYTE, pcbPackedCredentials: *mut DWORD, ) -> BOOL368     pub fn CredPackAuthenticationBufferA(
369         dwFlags: DWORD,
370         pszUserName: LPSTR,
371         pszPassword: LPSTR,
372         pPackedCredentials: PBYTE,
373         pcbPackedCredentials: *mut DWORD,
374     ) -> BOOL;
CredProtectW( fAsSelf: BOOL, pszCredentials: LPWSTR, cchCredentials: DWORD, pszProtectedCredentials: LPWSTR, pcchMaxChars: *mut DWORD, ProtectionType: *mut CRED_PROTECTION_TYPE, ) -> BOOL375     pub fn CredProtectW(
376         fAsSelf: BOOL,
377         pszCredentials: LPWSTR,
378         cchCredentials: DWORD,
379         pszProtectedCredentials: LPWSTR,
380         pcchMaxChars: *mut DWORD,
381         ProtectionType: *mut CRED_PROTECTION_TYPE,
382     ) -> BOOL;
CredProtectA( fAsSelf: BOOL, pszCredentials: LPSTR, cchCredentials: DWORD, pszProtectedCredentials: LPSTR, pcchMaxChars: *mut DWORD, ProtectionType: *mut CRED_PROTECTION_TYPE, ) -> BOOL383     pub fn CredProtectA(
384         fAsSelf: BOOL,
385         pszCredentials: LPSTR,
386         cchCredentials: DWORD,
387         pszProtectedCredentials: LPSTR,
388         pcchMaxChars: *mut DWORD,
389         ProtectionType: *mut CRED_PROTECTION_TYPE,
390     ) -> BOOL;
CredUnprotectW( fAsSelf: BOOL, pszProtectedCredentials: LPWSTR, cchCredentials: DWORD, pszCredentials: LPWSTR, pcchMaxChars: *mut DWORD, ) -> BOOL391     pub fn CredUnprotectW(
392         fAsSelf: BOOL,
393         pszProtectedCredentials: LPWSTR,
394         cchCredentials: DWORD,
395         pszCredentials: LPWSTR,
396         pcchMaxChars: *mut DWORD,
397     ) -> BOOL;
CredUnprotectA( fAsSelf: BOOL, pszProtectedCredentials: LPSTR, cchCredentials: DWORD, pszCredentials: LPSTR, pcchMaxChars: *mut DWORD, ) -> BOOL398     pub fn CredUnprotectA(
399         fAsSelf: BOOL,
400         pszProtectedCredentials: LPSTR,
401         cchCredentials: DWORD,
402         pszCredentials: LPSTR,
403         pcchMaxChars: *mut DWORD,
404     ) -> BOOL;
CredIsProtectedW( pszProtectedCredentials: LPWSTR, pProtectionType: *mut CRED_PROTECTION_TYPE, ) -> BOOL405     pub fn CredIsProtectedW(
406         pszProtectedCredentials: LPWSTR,
407         pProtectionType: *mut CRED_PROTECTION_TYPE,
408     ) -> BOOL;
CredIsProtectedA( pszProtectedCredentials: LPSTR, pProtectionType: *mut CRED_PROTECTION_TYPE, ) -> BOOL409     pub fn CredIsProtectedA(
410         pszProtectedCredentials: LPSTR,
411         pProtectionType: *mut CRED_PROTECTION_TYPE,
412     ) -> BOOL;
CredFindBestCredentialW( TargetName: LPCWSTR, Type: DWORD, Flags: DWORD, Credential: *mut PCREDENTIALW, ) -> BOOL413     pub fn CredFindBestCredentialW(
414         TargetName: LPCWSTR,
415         Type: DWORD,
416         Flags: DWORD,
417         Credential: *mut PCREDENTIALW,
418     ) -> BOOL;
CredFindBestCredentialA( TargetName: LPCSTR, Type: DWORD, Flags: DWORD, Credential: *mut PCREDENTIALA, ) -> BOOL419     pub fn CredFindBestCredentialA(
420         TargetName: LPCSTR,
421         Type: DWORD,
422         Flags: DWORD,
423         Credential: *mut PCREDENTIALA,
424     ) -> BOOL;
CredGetSessionTypes( MaximumPersistCount: DWORD, MaximumPersist: LPDWORD, ) -> BOOL425     pub fn CredGetSessionTypes(
426         MaximumPersistCount: DWORD,
427         MaximumPersist: LPDWORD,
428     ) -> BOOL;
CredFree( Buffer: PVOID, )429     pub fn CredFree(
430         Buffer: PVOID,
431     );
CredUIPromptForCredentialsW( pUiInfo: PCREDUI_INFOW, pszTargetName: PCWSTR, pContext: PCtxtHandle, dwAuthError: DWORD, pszUserName: PWSTR, ulUserNameBufferSize: ULONG, pszPassword: PWSTR, ulPasswordBufferSize: ULONG, save: *mut BOOL, dwFlags: DWORD, ) -> DWORD432     pub fn CredUIPromptForCredentialsW(
433         pUiInfo: PCREDUI_INFOW,
434         pszTargetName: PCWSTR,
435         pContext: PCtxtHandle,
436         dwAuthError: DWORD,
437         pszUserName: PWSTR,
438         ulUserNameBufferSize: ULONG,
439         pszPassword: PWSTR,
440         ulPasswordBufferSize: ULONG,
441         save: *mut BOOL,
442         dwFlags: DWORD,
443     ) -> DWORD;
CredUIPromptForCredentialsA( pUiInfo: PCREDUI_INFOA, pszTargetName: PCSTR, pContext: PCtxtHandle, dwAuthError: DWORD, pszUserName: PSTR, ulUserNameBufferSize: ULONG, pszPassword: PSTR, ulPasswordBufferSize: ULONG, save: *mut BOOL, dwFlags: DWORD, ) -> DWORD444     pub fn CredUIPromptForCredentialsA(
445         pUiInfo: PCREDUI_INFOA,
446         pszTargetName: PCSTR,
447         pContext: PCtxtHandle,
448         dwAuthError: DWORD,
449         pszUserName: PSTR,
450         ulUserNameBufferSize: ULONG,
451         pszPassword: PSTR,
452         ulPasswordBufferSize: ULONG,
453         save: *mut BOOL,
454         dwFlags: DWORD,
455     ) -> DWORD;
CredUIPromptForWindowsCredentialsW( pUiInfo: PCREDUI_INFOW, dwAuthError: DWORD, pulAuthPackage: *mut ULONG, pvInAuthBuffer: LPCVOID, ulInAuthBufferSize: ULONG, ppvOutAuthBuffer: *mut LPVOID, pulOutAuthBufferSize: *mut ULONG, pfSave: *mut BOOL, dwFlags: DWORD, ) -> DWORD456     pub fn CredUIPromptForWindowsCredentialsW(
457         pUiInfo: PCREDUI_INFOW,
458         dwAuthError: DWORD,
459         pulAuthPackage: *mut ULONG,
460         pvInAuthBuffer: LPCVOID,
461         ulInAuthBufferSize: ULONG,
462         ppvOutAuthBuffer: *mut LPVOID,
463         pulOutAuthBufferSize: *mut ULONG,
464         pfSave: *mut BOOL,
465         dwFlags: DWORD,
466     ) -> DWORD;
CredUIPromptForWindowsCredentialsA( pUiInfo: PCREDUI_INFOA, dwAuthError: DWORD, pulAuthPackage: *mut ULONG, pvInAuthBuffer: LPCVOID, ulInAuthBufferSize: ULONG, ppvOutAuthBuffer: *mut LPVOID, pulOutAuthBufferSize: *mut ULONG, pfSave: *mut BOOL, dwFlags: DWORD, ) -> DWORD467     pub fn CredUIPromptForWindowsCredentialsA(
468         pUiInfo: PCREDUI_INFOA,
469         dwAuthError: DWORD,
470         pulAuthPackage: *mut ULONG,
471         pvInAuthBuffer: LPCVOID,
472         ulInAuthBufferSize: ULONG,
473         ppvOutAuthBuffer: *mut LPVOID,
474         pulOutAuthBufferSize: *mut ULONG,
475         pfSave: *mut BOOL,
476         dwFlags: DWORD,
477     ) -> DWORD;
CredUIParseUserNameW( userName: PCWSTR, user: *mut WCHAR, userBufferSize: ULONG, domain: *mut WCHAR, domainBufferSize: ULONG, ) -> DWORD478     pub fn CredUIParseUserNameW(
479         userName: PCWSTR,
480         user: *mut WCHAR,
481         userBufferSize: ULONG,
482         domain: *mut WCHAR,
483         domainBufferSize: ULONG,
484     ) -> DWORD;
CredUIParseUserNameA( userName: PCSTR, user: *mut CHAR, userBufferSize: ULONG, domain: *mut CHAR, domainBufferSize: ULONG, ) -> DWORD485     pub fn CredUIParseUserNameA(
486         userName: PCSTR,
487         user: *mut CHAR,
488         userBufferSize: ULONG,
489         domain: *mut CHAR,
490         domainBufferSize: ULONG,
491     ) -> DWORD;
CredUICmdLinePromptForCredentialsW( pszTargetName: PCWSTR, pContext: PCtxtHandle, dwAuthError: DWORD, UserName: PWSTR, ulUserBufferSize: ULONG, pszPassword: PWSTR, ulPasswordBufferSize: ULONG, pfSave: PBOOL, dwFlags: DWORD, ) -> DWORD492     pub fn CredUICmdLinePromptForCredentialsW(
493         pszTargetName: PCWSTR,
494         pContext: PCtxtHandle,
495         dwAuthError: DWORD,
496         UserName: PWSTR,
497         ulUserBufferSize: ULONG,
498         pszPassword: PWSTR,
499         ulPasswordBufferSize: ULONG,
500         pfSave: PBOOL,
501         dwFlags: DWORD,
502     ) -> DWORD;
CredUICmdLinePromptForCredentialsA( pszTargetName: PCSTR, pContext: PCtxtHandle, dwAuthError: DWORD, UserName: PSTR, ulUserBufferSize: ULONG, pszPassword: PSTR, ulPasswordBufferSize: ULONG, pfSave: PBOOL, dwFlags: DWORD, ) -> DWORD503     pub fn CredUICmdLinePromptForCredentialsA(
504         pszTargetName: PCSTR,
505         pContext: PCtxtHandle,
506         dwAuthError: DWORD,
507         UserName: PSTR,
508         ulUserBufferSize: ULONG,
509         pszPassword: PSTR,
510         ulPasswordBufferSize: ULONG,
511         pfSave: PBOOL,
512         dwFlags: DWORD,
513     ) -> DWORD;
CredUIConfirmCredentialsW( pszTargetName: PCWSTR, bConfirm: BOOL, ) -> DWORD514     pub fn CredUIConfirmCredentialsW(
515         pszTargetName: PCWSTR,
516         bConfirm: BOOL,
517     ) -> DWORD;
CredUIConfirmCredentialsA( pszTargetName: PCSTR, bConfirm: BOOL, ) -> DWORD518     pub fn CredUIConfirmCredentialsA(
519         pszTargetName: PCSTR,
520         bConfirm: BOOL,
521     ) -> DWORD;
CredUIStoreSSOCredW( pszRealm: PCWSTR, pszUsername: PCWSTR, pszPassword: PCWSTR, bPersist: BOOL, ) -> DWORD522     pub fn CredUIStoreSSOCredW(
523         pszRealm: PCWSTR,
524         pszUsername: PCWSTR,
525         pszPassword: PCWSTR,
526         bPersist: BOOL,
527     ) -> DWORD;
CredUIReadSSOCredW( pszRealm: PCWSTR, ppszUsername: *mut PWSTR, ) -> DWORD528     pub fn CredUIReadSSOCredW(
529         pszRealm: PCWSTR,
530         ppszUsername: *mut PWSTR,
531     ) -> DWORD;
532 }
533