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