#include <stdarg.h>
#include <time.h>
#include <limits.h>
#include "windef.h"
#include "winbase.h"
#include "winreg.h"
#include "wincred.h"
#include "winternl.h"
#include "crypt.h"
#include "wine/unicode.h"
#include "wine/debug.h"
#include "advapi32_misc.h"

Include dependency graph for cred.c:

Macros
#define	KEY_SIZE 8

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (cred)

static DWORD	read_credential_blob (HKEY hkey, const BYTE key_data[KEY_SIZE], LPBYTE credential_blob, DWORD *credential_blob_size)

static DWORD	registry_read_credential (HKEY hkey, PCREDENTIALW credential, const BYTE key_data[KEY_SIZE], char buffer, DWORD len)

static DWORD	write_credential_blob (HKEY hkey, LPCWSTR target_name, DWORD type, const BYTE key_data[KEY_SIZE], const BYTE *credential_blob, DWORD credential_blob_size)

static DWORD	registry_write_credential (HKEY hkey, const CREDENTIALW *credential, const BYTE key_data[KEY_SIZE], BOOL preserve_blob)

static DWORD	open_cred_mgr_key (HKEY *hkey, BOOL open_for_write)

static DWORD	get_cred_mgr_encryption_key (HKEY hkeyMgr, BYTE key_data[KEY_SIZE])

static LPWSTR	get_key_name_for_target (LPCWSTR target_name, DWORD type)

static BOOL	registry_credential_matches_filter (HKEY hkeyCred, LPCWSTR filter)

static DWORD	registry_enumerate_credentials (HKEY hkeyMgr, LPCWSTR filter, LPWSTR target_name, DWORD target_name_len, const BYTE key_data[KEY_SIZE], PCREDENTIALW credentials, char buffer, DWORD len, DWORD *count)

static INT	convert_PCREDENTIALW_to_PCREDENTIALA (const CREDENTIALW *CredentialW, PCREDENTIALA CredentialA, DWORD len)

static INT	convert_PCREDENTIALA_to_PCREDENTIALW (const CREDENTIALA *CredentialA, PCREDENTIALW CredentialW, INT len)

BOOL WINAPI	CredDeleteA (LPCSTR TargetName, DWORD Type, DWORD Flags)

BOOL WINAPI	CredDeleteW (LPCWSTR TargetName, DWORD Type, DWORD Flags)

BOOL WINAPI	CredEnumerateA (LPCSTR Filter, DWORD Flags, DWORD Count, PCREDENTIALA *Credentials)

BOOL WINAPI	CredEnumerateW (LPCWSTR Filter, DWORD Flags, DWORD Count, PCREDENTIALW *Credentials)

VOID WINAPI	CredFree (PVOID Buffer)

BOOL WINAPI	CredReadA (LPCSTR TargetName, DWORD Type, DWORD Flags, PCREDENTIALA *Credential)

BOOL WINAPI	CredReadW (LPCWSTR TargetName, DWORD Type, DWORD Flags, PCREDENTIALW *Credential)

BOOL WINAPI	CredReadDomainCredentialsA (PCREDENTIAL_TARGET_INFORMATIONA TargetInformation, DWORD Flags, DWORD Size, PCREDENTIALA *Credentials)

BOOL WINAPI	CredReadDomainCredentialsW (PCREDENTIAL_TARGET_INFORMATIONW TargetInformation, DWORD Flags, DWORD Size, PCREDENTIALW *Credentials)

BOOL WINAPI	CredWriteA (PCREDENTIALA Credential, DWORD Flags)

BOOL WINAPI	CredWriteW (PCREDENTIALW Credential, DWORD Flags)

WINADVAPI BOOL WINAPI	CredGetSessionTypes (DWORD persistCount, LPDWORD persists)

BOOL WINAPI	CredMarshalCredentialA (CRED_MARSHAL_TYPE type, PVOID cred, LPSTR *out)

static UINT	cred_encode (const char bin, unsigned int len, WCHAR cred)

BOOL WINAPI	CredMarshalCredentialW (CRED_MARSHAL_TYPE type, PVOID cred, LPWSTR *out)

BOOL WINAPI	CredUnmarshalCredentialA (LPCSTR cred, PCRED_MARSHAL_TYPE type, PVOID *out)

static char	char_decode (WCHAR c)

static BOOL	cred_decode (const WCHAR cred, unsigned int len, char buf)

BOOL WINAPI	CredUnmarshalCredentialW (LPCWSTR cred, PCRED_MARSHAL_TYPE type, PVOID *out)

BOOL WINAPI	CredIsMarshaledCredentialW (LPCWSTR name)

BOOL WINAPI	CredIsMarshaledCredentialA (LPCSTR name)

Variables
static const WCHAR	wszCredentialManagerKey []

static const WCHAR	wszEncryptionKeyValue [] = {'E','n','c','r','y','p','t','i','o','n','K','e','y',0}

static const WCHAR	wszFlagsValue [] = {'F','l','a','g','s',0}

static const WCHAR	wszTypeValue [] = {'T','y','p','e',0}

static const WCHAR	wszCommentValue [] = {'C','o','m','m','e','n','t',0}

static const WCHAR	wszLastWrittenValue [] = {'L','a','s','t','W','r','i','t','t','e','n',0}

static const WCHAR	wszPersistValue [] = {'P','e','r','s','i','s','t',0}

static const WCHAR	wszTargetAliasValue [] = {'T','a','r','g','e','t','A','l','i','a','s',0}

static const WCHAR	wszUserNameValue [] = {'U','s','e','r','N','a','m','e',0}

static const WCHAR	wszPasswordValue [] = {'P','a','s','s','w','o','r','d',0}

Macro Definition Documentation

◆ KEY_SIZE

#define KEY_SIZE 8

Definition at line 53 of file cred.c.

Function Documentation

◆ char_decode()

static char char_decode ( WCHAR c )

inlinestatic

Definition at line 2067 of file cred.c.

{
    if (c >= 'A' && c <= 'Z') return c - 'A';
    if (c >= 'a' && c <= 'z') return c - 'a' + 26;
    if (c >= '0' && c <= '9') return c - '0' + 52;
    if (c == '#') return 62;
    if (c == '-') return 63;
    return 64;
}

Referenced by cred_decode(), and CredUnmarshalCredentialW().

◆ convert_PCREDENTIALA_to_PCREDENTIALW()

static INT convert_PCREDENTIALA_to_PCREDENTIALW	(	const CREDENTIALA *	CredentialA,
		PCREDENTIALW	CredentialW,
		INT	len
	)

static

Definition at line 1046 of file cred.c.

{
    char *buffer;
    INT string_len;
    INT needed = sizeof(CREDENTIALW);
 
    if (!CredentialW)
    {
        if (CredentialA->TargetName)
            needed += sizeof(WCHAR) * MultiByteToWideChar(CP_ACP, 0, CredentialA->TargetName, -1, NULL, 0);
        if (CredentialA->Comment)
            needed += sizeof(WCHAR) * MultiByteToWideChar(CP_ACP, 0, CredentialA->Comment, -1, NULL, 0);
        needed += CredentialA->CredentialBlobSize;
        if (CredentialA->TargetAlias)
            needed += sizeof(WCHAR) * MultiByteToWideChar(CP_ACP, 0, CredentialA->TargetAlias, -1, NULL, 0);
        if (CredentialA->UserName)
            needed += sizeof(WCHAR) * MultiByteToWideChar(CP_ACP, 0, CredentialA->UserName, -1, NULL, 0);
 
        return needed;
    }
 
    buffer = (char *)CredentialW + sizeof(CREDENTIALW);
    len -= sizeof(CREDENTIALW);
    CredentialW->Flags = CredentialA->Flags;
    CredentialW->Type = CredentialA->Type;
    if (CredentialA->TargetName)
    {
        CredentialW->TargetName = (LPWSTR)buffer;
        string_len = MultiByteToWideChar(CP_ACP, 0, CredentialA->TargetName, -1, CredentialW->TargetName, len / sizeof(WCHAR));
        buffer += sizeof(WCHAR) * string_len;
        needed += sizeof(WCHAR) * string_len;
        len -= sizeof(WCHAR) * string_len;
    }
    else
        CredentialW->TargetName = NULL;
    if (CredentialA->Comment)
    {
        CredentialW->Comment = (LPWSTR)buffer;
        string_len = MultiByteToWideChar(CP_ACP, 0, CredentialA->Comment, -1, CredentialW->Comment, len / sizeof(WCHAR));
        buffer += sizeof(WCHAR) * string_len;
        needed += sizeof(WCHAR) * string_len;
        len -= sizeof(WCHAR) * string_len;
    }
    else
        CredentialW->Comment = NULL;
    CredentialW->LastWritten = CredentialA->LastWritten;
    CredentialW->CredentialBlobSize = CredentialA->CredentialBlobSize;
    if (CredentialA->CredentialBlobSize)
    {
        CredentialW->CredentialBlob =(LPBYTE)buffer;
        memcpy(CredentialW->CredentialBlob, CredentialA->CredentialBlob,
               CredentialA->CredentialBlobSize);
        buffer += CredentialA->CredentialBlobSize;
        needed += CredentialA->CredentialBlobSize;
        len -= CredentialA->CredentialBlobSize;
    }
    else
        CredentialW->CredentialBlob = NULL;
    CredentialW->Persist = CredentialA->Persist;
    CredentialW->AttributeCount = 0;
    CredentialW->Attributes = NULL; /* FIXME */
    if (CredentialA->TargetAlias)
    {
        CredentialW->TargetAlias = (LPWSTR)buffer;
        string_len = MultiByteToWideChar(CP_ACP, 0, CredentialA->TargetAlias, -1, CredentialW->TargetAlias, len / sizeof(WCHAR));
        buffer += sizeof(WCHAR) * string_len;
        needed += sizeof(WCHAR) * string_len;
        len -= sizeof(WCHAR) * string_len;
    }
    else
        CredentialW->TargetAlias = NULL;
    if (CredentialA->UserName)
    {
        CredentialW->UserName = (LPWSTR)buffer;
        string_len = MultiByteToWideChar(CP_ACP, 0, CredentialA->UserName, -1, CredentialW->UserName, len / sizeof(WCHAR));
        needed += sizeof(WCHAR) * string_len;
    }
    else
        CredentialW->UserName = NULL;
 
    return needed;
}

Referenced by CredWriteA().

◆ convert_PCREDENTIALW_to_PCREDENTIALA()

static INT convert_PCREDENTIALW_to_PCREDENTIALA	(	const CREDENTIALW *	CredentialW,
		PCREDENTIALA	CredentialA,
		DWORD	len
	)

static

Definition at line 955 of file cred.c.

{
    char *buffer;
    INT string_len;
    INT needed = sizeof(CREDENTIALA);
 
    if (!CredentialA)
    {
        if (CredentialW->TargetName)
            needed += WideCharToMultiByte(CP_ACP, 0, CredentialW->TargetName, -1, NULL, 0, NULL, NULL);
        if (CredentialW->Comment)
            needed += WideCharToMultiByte(CP_ACP, 0, CredentialW->Comment, -1, NULL, 0, NULL, NULL);
        needed += CredentialW->CredentialBlobSize;
        if (CredentialW->TargetAlias)
            needed += WideCharToMultiByte(CP_ACP, 0, CredentialW->TargetAlias, -1, NULL, 0, NULL, NULL);
        if (CredentialW->UserName)
            needed += WideCharToMultiByte(CP_ACP, 0, CredentialW->UserName, -1, NULL, 0, NULL, NULL);
 
        return needed;
    }
 
 
    buffer = (char *)CredentialA + sizeof(CREDENTIALA);
    len -= sizeof(CREDENTIALA);
    CredentialA->Flags = CredentialW->Flags;
    CredentialA->Type = CredentialW->Type;
 
    if (CredentialW->TargetName)
    {
        CredentialA->TargetName = buffer;
        string_len = WideCharToMultiByte(CP_ACP, 0, CredentialW->TargetName, -1, buffer, len, NULL, NULL);
        buffer += string_len;
        needed += string_len;
        len -= string_len;
    }
    else
        CredentialA->TargetName = NULL;
    if (CredentialW->Comment)
    {
        CredentialA->Comment = buffer;
        string_len = WideCharToMultiByte(CP_ACP, 0, CredentialW->Comment, -1, buffer, len, NULL, NULL);
        buffer += string_len;
        needed += string_len;
        len -= string_len;
    }
    else
        CredentialA->Comment = NULL;
    CredentialA->LastWritten = CredentialW->LastWritten;
    CredentialA->CredentialBlobSize = CredentialW->CredentialBlobSize;
    if (CredentialW->CredentialBlobSize && (CredentialW->CredentialBlobSize <= len))
    {
        CredentialA->CredentialBlob =(LPBYTE)buffer;
        memcpy(CredentialA->CredentialBlob, CredentialW->CredentialBlob,
               CredentialW->CredentialBlobSize);
        buffer += CredentialW->CredentialBlobSize;
        needed += CredentialW->CredentialBlobSize;
        len -= CredentialW->CredentialBlobSize;
    }
    else
        CredentialA->CredentialBlob = NULL;
    CredentialA->Persist = CredentialW->Persist;
    CredentialA->AttributeCount = 0;
    CredentialA->Attributes = NULL; /* FIXME */
    if (CredentialW->TargetAlias)
    {
        CredentialA->TargetAlias = buffer;
        string_len = WideCharToMultiByte(CP_ACP, 0, CredentialW->TargetAlias, -1, buffer, len, NULL, NULL);
        buffer += string_len;
        needed += string_len;
        len -= string_len;
    }
    else
        CredentialA->TargetAlias = NULL;
    if (CredentialW->UserName)
    {
        CredentialA->UserName = buffer;
        string_len = WideCharToMultiByte(CP_ACP, 0, CredentialW->UserName, -1, buffer, len, NULL, NULL);
        needed += string_len;
    }
    else
        CredentialA->UserName = NULL;
 
    return needed;
}

Referenced by CredEnumerateA(), CredReadA(), and CredReadDomainCredentialsA().

◆ cred_decode()

static BOOL cred_decode	(	const WCHAR *	cred,
		unsigned int	len,
		char *	buf
	)

static

Definition at line 2077 of file cred.c.

{
    unsigned int i = 0;
    char c0, c1, c2, c3;
    const WCHAR *p = cred;
 
    while (len >= 4)
    {
        if ((c0 = char_decode( p[0] )) > 63) return FALSE;
        if ((c1 = char_decode( p[1] )) > 63) return FALSE;
        if ((c2 = char_decode( p[2] )) > 63) return FALSE;
        if ((c3 = char_decode( p[3] )) > 63) return FALSE;
 
        buf[i + 0] = (c1 << 6) | c0;
        buf[i + 1] = (c2 << 4) | (c1 >> 2);
        buf[i + 2] = (c3 << 2) | (c2 >> 4);
        len -= 4;
        i += 3;
        p += 4;
    }
    if (len == 3)
    {
        if ((c0 = char_decode( p[0] )) > 63) return FALSE;
        if ((c1 = char_decode( p[1] )) > 63) return FALSE;
        if ((c2 = char_decode( p[2] )) > 63) return FALSE;
 
        buf[i + 0] = (c1 << 6) | c0;
        buf[i + 1] = (c2 << 4) | (c1 >> 2);
    }
    else if (len == 2)
    {
        if ((c0 = char_decode( p[0] )) > 63) return FALSE;
        if ((c1 = char_decode( p[1] )) > 63) return FALSE;
 
        buf[i + 0] = (c1 << 6) | c0;
    }
    else if (len == 1)
    {
        return FALSE;
    }
    return TRUE;
}

Referenced by CredIsMarshaledCredentialW(), and CredUnmarshalCredentialW().

◆ cred_encode()

static UINT cred_encode	(	const char *	bin,
		unsigned int	len,
		WCHAR *	cred
	)

static

Definition at line 1961 of file cred.c.

{
    static const char enc[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789#-";
    UINT n = 0, x;
 
    while (len > 0)
    {
        cred[n++] = enc[bin[0] & 0x3f];
        x = (bin[0] & 0xc0) >> 6;
        if (len == 1)
        {
            cred[n++] = enc[x];
            break;
        }
        cred[n++] = enc[((bin[1] & 0xf) << 2) | x];
        x = (bin[1] & 0xf0) >> 4;
        if (len == 2)
        {
            cred[n++] = enc[x];
            break;
        }
        cred[n++] = enc[((bin[2] & 0x3) << 4) | x];
        cred[n++] = enc[(bin[2] & 0xfc) >> 2];
        bin += 3;
        len -= 3;
    }
    return n;
}

Referenced by CredMarshalCredentialW().

◆ CredDeleteA()

BOOL WINAPI CredDeleteA	(	LPCSTR	TargetName,
		DWORD	Type,
		DWORD	Flags
	)

Definition at line 1132 of file cred.c.

{
    LPWSTR TargetNameW;
    DWORD len;
    BOOL ret;
 
    TRACE("(%s, %d, 0x%x)\n", debugstr_a(TargetName), Type, Flags);
 
    if (!TargetName)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    len = MultiByteToWideChar(CP_ACP, 0, TargetName, -1, NULL, 0);
    TargetNameW = heap_alloc(len * sizeof(WCHAR));
    if (!TargetNameW)
    {
        SetLastError(ERROR_OUTOFMEMORY);
        return FALSE;
    }
    MultiByteToWideChar(CP_ACP, 0, TargetName, -1, TargetNameW, len);
 
    ret = CredDeleteW(TargetNameW, Type, Flags);
 
    heap_free(TargetNameW);
 
    return ret;
}

◆ CredDeleteW()

BOOL WINAPI CredDeleteW	(	LPCWSTR	TargetName,
		DWORD	Type,
		DWORD	Flags
	)

Definition at line 1165 of file cred.c.

{
    HKEY hkeyMgr;
    DWORD ret;
    LPWSTR key_name;
 
    TRACE("(%s, %d, 0x%x)\n", debugstr_w(TargetName), Type, Flags);
 
    if (!TargetName)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (Type != CRED_TYPE_GENERIC && Type != CRED_TYPE_DOMAIN_PASSWORD)
    {
        FIXME("unhandled type %d\n", Type);
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (Flags)
    {
        FIXME("unhandled flags 0x%x\n", Flags);
        SetLastError(ERROR_INVALID_FLAGS);
        return FALSE;
    }
 
#ifdef __APPLE__
    if (Type == CRED_TYPE_DOMAIN_PASSWORD)
    {
        ret = mac_delete_credential(TargetName);
        if (ret == ERROR_SUCCESS)
            return TRUE;
    }
#endif
 
    ret = open_cred_mgr_key(&hkeyMgr, TRUE);
    if (ret != ERROR_SUCCESS)
    {
        WARN("couldn't open/create manager key, error %d\n", ret);
        SetLastError(ERROR_NO_SUCH_LOGON_SESSION);
        return FALSE;
    }
 
    key_name = get_key_name_for_target(TargetName, Type);
    ret = RegDeleteKeyW(hkeyMgr, key_name);
    heap_free(key_name);
    RegCloseKey(hkeyMgr);
    if (ret != ERROR_SUCCESS)
    {
        SetLastError(ERROR_NOT_FOUND);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by CredDeleteA().

◆ CredEnumerateA()

BOOL WINAPI CredEnumerateA	(	LPCSTR	Filter,
		DWORD	Flags,
		DWORD *	Count,
		PCREDENTIALA **	Credentials
	)

Definition at line 1226 of file cred.c.

{
    LPWSTR FilterW;
    PCREDENTIALW *CredentialsW;
    DWORD i;
    INT len;
    INT needed;
    char *buffer;
 
    TRACE("(%s, 0x%x, %p, %p)\n", debugstr_a(Filter), Flags, Count, Credentials);
 
    if (Filter)
    {
        len = MultiByteToWideChar(CP_ACP, 0, Filter, -1, NULL, 0);
        FilterW = heap_alloc(len * sizeof(WCHAR));
        if (!FilterW)
        {
            SetLastError(ERROR_OUTOFMEMORY);
            return FALSE;
        }
        MultiByteToWideChar(CP_ACP, 0, Filter, -1, FilterW, len);
    }
    else
        FilterW = NULL;
 
    if (!CredEnumerateW(FilterW, Flags, Count, &CredentialsW))
    {
        heap_free(FilterW);
        return FALSE;
    }
    heap_free(FilterW);
 
    len = *Count * sizeof(PCREDENTIALA);
    for (i = 0; i < *Count; i++)
        len += convert_PCREDENTIALW_to_PCREDENTIALA(CredentialsW[i], NULL, 0);
 
    *Credentials = heap_alloc(len);
    if (!*Credentials)
    {
        CredFree(CredentialsW);
        SetLastError(ERROR_OUTOFMEMORY);
        return FALSE;
    }
 
    buffer = (char *)&(*Credentials)[*Count];
    len -= *Count * sizeof(PCREDENTIALA);
    for (i = 0; i < *Count; i++)
    {
        (*Credentials)[i] = (PCREDENTIALA)buffer;
        needed = convert_PCREDENTIALW_to_PCREDENTIALA(CredentialsW[i], (*Credentials)[i], len);
        buffer += needed;
        len -= needed;
    }
 
    CredFree(CredentialsW);
 
    return TRUE;
}

◆ CredEnumerateW()

BOOL WINAPI CredEnumerateW	(	LPCWSTR	Filter,
		DWORD	Flags,
		DWORD *	Count,
		PCREDENTIALW **	Credentials
	)

Definition at line 1289 of file cred.c.

{
    HKEY hkeyMgr;
    DWORD ret;
    LPWSTR target_name;
    DWORD target_name_len;
    DWORD len;
    char *buffer;
    BYTE key_data[KEY_SIZE];
 
    TRACE("(%s, 0x%x, %p, %p)\n", debugstr_w(Filter), Flags, Count, Credentials);
 
    if (Flags)
    {
        SetLastError(ERROR_INVALID_FLAGS);
        return FALSE;
    }
 
    ret = open_cred_mgr_key(&hkeyMgr, FALSE);
    if (ret != ERROR_SUCCESS)
    {
        WARN("couldn't open/create manager key, error %d\n", ret);
        SetLastError(ERROR_NO_SUCH_LOGON_SESSION);
        return FALSE;
    }
 
    ret = get_cred_mgr_encryption_key(hkeyMgr, key_data);
    if (ret != ERROR_SUCCESS)
    {
        RegCloseKey(hkeyMgr);
        SetLastError(ret);
        return FALSE;
    }
 
    ret = RegQueryInfoKeyW(hkeyMgr, NULL, NULL, NULL, NULL, &target_name_len, NULL, NULL, NULL, NULL, NULL, NULL);
    if (ret != ERROR_SUCCESS)
    {
        RegCloseKey(hkeyMgr);
        SetLastError(ret);
        return FALSE;
    }
 
    target_name = heap_alloc((target_name_len+1)*sizeof(WCHAR));
    if (!target_name)
    {
        RegCloseKey(hkeyMgr);
        SetLastError(ERROR_OUTOFMEMORY);
        return FALSE;
    }
 
    *Count = 0;
    len = 0;
    ret = registry_enumerate_credentials(hkeyMgr, Filter, target_name, target_name_len,
                                         key_data, NULL, NULL, &len, Count);
#ifdef __APPLE__
    if (ret == ERROR_SUCCESS)
        ret = mac_enumerate_credentials(Filter, NULL, NULL, &len, Count);
#endif
    if (ret == ERROR_SUCCESS && *Count == 0)
        ret = ERROR_NOT_FOUND;
    if (ret != ERROR_SUCCESS)
    {
        heap_free(target_name);
        RegCloseKey(hkeyMgr);
        SetLastError(ret);
        return FALSE;
    }
    len += *Count * sizeof(PCREDENTIALW);
 
    if (ret == ERROR_SUCCESS)
    {
        buffer = heap_alloc(len);
        *Credentials = (PCREDENTIALW *)buffer;
        if (buffer)
        {
            buffer += *Count * sizeof(PCREDENTIALW);
            *Count = 0;
            ret = registry_enumerate_credentials(hkeyMgr, Filter, target_name,
                                                 target_name_len, key_data,
                                                 *Credentials, &buffer, &len,
                                                 Count);
#ifdef __APPLE__
            if (ret == ERROR_SUCCESS)
                ret = mac_enumerate_credentials(Filter, *Credentials,
                                                buffer, &len, Count);
#endif
        }
        else
            ret = ERROR_OUTOFMEMORY;
    }
 
    heap_free(target_name);
    RegCloseKey(hkeyMgr);
 
    if (ret != ERROR_SUCCESS)
    {
        SetLastError(ret);
        return FALSE;
    }
    return TRUE;
}

Referenced by CredDialogFillUsernameCombo(), CredEnumerateA(), and find_existing_credential().

◆ CredFree()

VOID WINAPI CredFree ( PVOID Buffer )

Definition at line 1395 of file cred.c.

{
    heap_free(Buffer);
}

Referenced by CredDialogFillUsernameCombo(), CredEnumerateA(), CredReadA(), CredReadDomainCredentialsA(), find_existing_credential(), and ntlm_InitializeSecurityContextW().

◆ CredGetSessionTypes()

WINADVAPI BOOL WINAPI CredGetSessionTypes	(	DWORD	persistCount,
		LPDWORD	persists
	)

Definition at line 1920 of file cred.c.

{
    TRACE("(%u, %p)\n", persistCount, persists);
 
    memset(persists, CRED_PERSIST_NONE, persistCount*sizeof(*persists));
    if (CRED_TYPE_GENERIC < persistCount)
    {
        persists[CRED_TYPE_GENERIC] = CRED_PERSIST_ENTERPRISE;
 
        if (CRED_TYPE_DOMAIN_PASSWORD < persistCount)
        {
            persists[CRED_TYPE_DOMAIN_PASSWORD] = CRED_PERSIST_ENTERPRISE;
        }
    }
    return TRUE;
}

◆ CredIsMarshaledCredentialA()

BOOL WINAPI CredIsMarshaledCredentialA ( LPCSTR name )

Definition at line 2235 of file cred.c.

{
    LPWSTR nameW = NULL;
    BOOL res;
    int len;
 
    TRACE("(%s)\n", debugstr_a(name));
 
    if (name)
    {
        len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0);
        nameW = heap_alloc(len * sizeof(WCHAR));
        MultiByteToWideChar(CP_ACP, 0, name, -1, nameW, len);
    }
 
    res = CredIsMarshaledCredentialW(nameW);
    heap_free(nameW);
    return res;
}

◆ CredIsMarshaledCredentialW()

BOOL WINAPI CredIsMarshaledCredentialW ( LPCWSTR name )

Definition at line 2201 of file cred.c.

{
    TRACE("(%s)\n", debugstr_w(name));
 
    if (name && name[0] == '@' && name[1] == '@' && name[2] > 'A' && name[3])
    {
        char hash[CERT_HASH_LENGTH];
        int len = strlenW(name + 3 );
        DWORD size;
 
        if ((name[2] - 'A') == CertCredential && (len == 27) && cred_decode(name + 3, len, hash))
            return TRUE;
 
        if (((name[2] - 'A') == UsernameTargetCredential) &&
            (len >= 9) && cred_decode(name + 3, 6, (char *)&size) && size)
            return TRUE;
 
        if ((name[2] - 'A') == BinaryBlobCredential)
            FIXME("BinaryBlobCredential not checked\n");
 
        if ((name[2] - 'A') > BinaryBlobCredential)
            TRACE("unknown type: %d\n", (name[2] - 'A'));
    }
 
    SetLastError(ERROR_INVALID_PARAMETER);
    return FALSE;
}

Referenced by CredIsMarshaledCredentialA().

◆ CredMarshalCredentialA()

BOOL WINAPI CredMarshalCredentialA	(	CRED_MARSHAL_TYPE	type,
		PVOID	cred,
		LPSTR *	out
	)

Definition at line 1940 of file cred.c.

{
    BOOL ret;
    WCHAR *outW;
 
    TRACE("%u, %p, %p\n", type, cred, out);
 
    if ((ret = CredMarshalCredentialW( type, cred, &outW )))
    {
        int len = WideCharToMultiByte( CP_ACP, 0, outW, -1, NULL, 0, NULL, NULL );
        if (!(*out = heap_alloc( len )))
        {
            heap_free( outW );
            return FALSE;
        }
        WideCharToMultiByte( CP_ACP, 0, outW, -1, *out, len, NULL, NULL );
        heap_free( outW );
    }
    return ret;
}

◆ CredMarshalCredentialW()

BOOL WINAPI CredMarshalCredentialW	(	CRED_MARSHAL_TYPE	type,
		PVOID	cred,
		LPWSTR *	out
	)

Definition at line 1993 of file cred.c.

{
    CERT_CREDENTIAL_INFO *cert = cred;
    USERNAME_TARGET_CREDENTIAL_INFO *target = cred;
    DWORD len, size;
    WCHAR *p;
 
    TRACE("%u, %p, %p\n", type, cred, out);
 
    if (!cred || (type == CertCredential && cert->cbSize < sizeof(*cert)) ||
        (type != CertCredential && type != UsernameTargetCredential && type != BinaryBlobCredential) ||
        (type == UsernameTargetCredential && (!target->UserName || !target->UserName[0])))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    switch (type)
    {
    case CertCredential:
    {
        size = (sizeof(cert->rgbHashOfCert) + 2) * 4 / 3;
        if (!(p = heap_alloc( (size + 4) * sizeof(WCHAR) ))) return FALSE;
        p[0] = '@';
        p[1] = '@';
        p[2] = 'A' + type;
        len = cred_encode( (const char *)cert->rgbHashOfCert, sizeof(cert->rgbHashOfCert), p + 3 );
        p[len + 3] = 0;
        break;
    }
    case UsernameTargetCredential:
    {
        len = strlenW( target->UserName );
        size = (sizeof(DWORD) + len * sizeof(WCHAR) + 2) * 4 / 3;
        if (!(p = heap_alloc( (size + 4) * sizeof(WCHAR) ))) return FALSE;
        p[0] = '@';
        p[1] = '@';
        p[2] = 'A' + type;
        size = len * sizeof(WCHAR);
        len = cred_encode( (const char *)&size, sizeof(DWORD), p + 3 );
        len += cred_encode( (const char *)target->UserName, size, p + 3 + len );
        p[len + 3] = 0;
        break;
    }
    case BinaryBlobCredential:
        FIXME("BinaryBlobCredential not implemented\n");
        return FALSE;
    default:
        return FALSE;
    }
    *out = p;
    return TRUE;
}

Referenced by CredMarshalCredentialA().

◆ CredReadA()

BOOL WINAPI CredReadA	(	LPCSTR	TargetName,
		DWORD	Type,
		DWORD	Flags,
		PCREDENTIALA *	Credential
	)

Definition at line 1403 of file cred.c.

{
    LPWSTR TargetNameW;
    PCREDENTIALW CredentialW;
    INT len;
 
    TRACE("(%s, %d, 0x%x, %p)\n", debugstr_a(TargetName), Type, Flags, Credential);
 
    if (!TargetName)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    len = MultiByteToWideChar(CP_ACP, 0, TargetName, -1, NULL, 0);
    TargetNameW = heap_alloc(len * sizeof(WCHAR));
    if (!TargetNameW)
    {
        SetLastError(ERROR_OUTOFMEMORY);
        return FALSE;
    }
    MultiByteToWideChar(CP_ACP, 0, TargetName, -1, TargetNameW, len);
 
    if (!CredReadW(TargetNameW, Type, Flags, &CredentialW))
    {
        heap_free(TargetNameW);
        return FALSE;
    }
    heap_free(TargetNameW);
 
    len = convert_PCREDENTIALW_to_PCREDENTIALA(CredentialW, NULL, 0);
    *Credential = heap_alloc(len);
    if (!*Credential)
    {
        SetLastError(ERROR_OUTOFMEMORY);
        return FALSE;
    }
    convert_PCREDENTIALW_to_PCREDENTIALA(CredentialW, *Credential, len);
 
    CredFree(CredentialW);
 
    return TRUE;
}

◆ CredReadDomainCredentialsA()

BOOL WINAPI CredReadDomainCredentialsA	(	PCREDENTIAL_TARGET_INFORMATIONA	TargetInformation,
		DWORD	Flags,
		DWORD *	Size,
		PCREDENTIALA **	Credentials
	)

Definition at line 1608 of file cred.c.

{
    PCREDENTIAL_TARGET_INFORMATIONW TargetInformationW;
    INT len;
    DWORD i;
    WCHAR *buffer, *end;
    BOOL ret;
    PCREDENTIALW* CredentialsW;
 
    TRACE("(%p, 0x%x, %p, %p)\n", TargetInformation, Flags, Size, Credentials);
 
    /* follow Windows behavior - do not test for NULL, initialize early */
    *Size = 0;
    *Credentials = NULL;
 
    if (!TargetInformation)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    len = sizeof(*TargetInformationW);
    if (TargetInformation->TargetName)
        len += MultiByteToWideChar(CP_ACP, 0, TargetInformation->TargetName, -1, NULL, 0) * sizeof(WCHAR);
    if (TargetInformation->NetbiosServerName)
        len += MultiByteToWideChar(CP_ACP, 0, TargetInformation->NetbiosServerName, -1, NULL, 0) * sizeof(WCHAR);
    if (TargetInformation->DnsServerName)
        len += MultiByteToWideChar(CP_ACP, 0, TargetInformation->DnsServerName, -1, NULL, 0) * sizeof(WCHAR);
    if (TargetInformation->NetbiosDomainName)
        len += MultiByteToWideChar(CP_ACP, 0, TargetInformation->NetbiosDomainName, -1, NULL, 0) * sizeof(WCHAR);
    if (TargetInformation->DnsDomainName)
        len += MultiByteToWideChar(CP_ACP, 0, TargetInformation->DnsDomainName, -1, NULL, 0) * sizeof(WCHAR);
    if (TargetInformation->DnsTreeName)
        len += MultiByteToWideChar(CP_ACP, 0, TargetInformation->DnsTreeName, -1, NULL, 0) * sizeof(WCHAR);
    if (TargetInformation->PackageName)
        len += MultiByteToWideChar(CP_ACP, 0, TargetInformation->PackageName, -1, NULL, 0) * sizeof(WCHAR);
 
    TargetInformationW = heap_alloc(len);
    if (!TargetInformationW)
    {
        SetLastError(ERROR_OUTOFMEMORY);
        return FALSE;
    }
    buffer = (WCHAR*)(TargetInformationW + 1);
    end = (WCHAR *)((char *)TargetInformationW + len);
 
    if (TargetInformation->TargetName)
    {
        TargetInformationW->TargetName = buffer;
        buffer += MultiByteToWideChar(CP_ACP, 0, TargetInformation->TargetName, -1,
                                      TargetInformationW->TargetName, end - buffer);
    } else
        TargetInformationW->TargetName = NULL;
 
    if (TargetInformation->NetbiosServerName)
    {
        TargetInformationW->NetbiosServerName = buffer;
        buffer += MultiByteToWideChar(CP_ACP, 0, TargetInformation->NetbiosServerName, -1,
                                      TargetInformationW->NetbiosServerName, end - buffer);
    } else
        TargetInformationW->NetbiosServerName = NULL;
 
    if (TargetInformation->DnsServerName)
    {
        TargetInformationW->DnsServerName = buffer;
        buffer += MultiByteToWideChar(CP_ACP, 0, TargetInformation->DnsServerName, -1,
                                      TargetInformationW->DnsServerName, end - buffer);
    } else
        TargetInformationW->DnsServerName = NULL;
 
    if (TargetInformation->NetbiosDomainName)
    {
        TargetInformationW->NetbiosDomainName = buffer;
        buffer += MultiByteToWideChar(CP_ACP, 0, TargetInformation->NetbiosDomainName, -1,
                                      TargetInformationW->NetbiosDomainName, end - buffer);
    } else
        TargetInformationW->NetbiosDomainName = NULL;
 
    if (TargetInformation->DnsDomainName)
    {
        TargetInformationW->DnsDomainName = buffer;
        buffer += MultiByteToWideChar(CP_ACP, 0, TargetInformation->DnsDomainName, -1,
                                      TargetInformationW->DnsDomainName, end - buffer);
    } else
        TargetInformationW->DnsDomainName = NULL;
 
    if (TargetInformation->DnsTreeName)
    {
        TargetInformationW->DnsTreeName = buffer;
        buffer += MultiByteToWideChar(CP_ACP, 0, TargetInformation->DnsTreeName, -1,
                                      TargetInformationW->DnsTreeName, end - buffer);
    } else
        TargetInformationW->DnsTreeName = NULL;
 
    if (TargetInformation->PackageName)
    {
        TargetInformationW->PackageName = buffer;
        MultiByteToWideChar(CP_ACP, 0, TargetInformation->PackageName, -1,
                            TargetInformationW->PackageName, end - buffer);
    } else
        TargetInformationW->PackageName = NULL;
 
    TargetInformationW->Flags = TargetInformation->Flags;
    TargetInformationW->CredTypeCount = TargetInformation->CredTypeCount;
    TargetInformationW->CredTypes = TargetInformation->CredTypes;
 
    ret = CredReadDomainCredentialsW(TargetInformationW, Flags, Size, &CredentialsW);
 
    heap_free(TargetInformationW);
 
    if (ret)
    {
        char *buf;
        INT needed;
 
        len = *Size * sizeof(PCREDENTIALA);
        for (i = 0; i < *Size; i++)
            len += convert_PCREDENTIALW_to_PCREDENTIALA(CredentialsW[i], NULL, 0);
 
        *Credentials = heap_alloc(len);
        if (!*Credentials)
        {
            CredFree(CredentialsW);
            SetLastError(ERROR_OUTOFMEMORY);
            return FALSE;
        }
 
        buf = (char *)&(*Credentials)[*Size];
        len -= *Size * sizeof(PCREDENTIALA);
        for (i = 0; i < *Size; i++)
        {
            (*Credentials)[i] = (PCREDENTIALA)buf;
            needed = convert_PCREDENTIALW_to_PCREDENTIALA(CredentialsW[i], (*Credentials)[i], len);
            buf += needed;
            len -= needed;
        }
 
        CredFree(CredentialsW);
    }
    return ret;
}

◆ CredReadDomainCredentialsW()

BOOL WINAPI CredReadDomainCredentialsW	(	PCREDENTIAL_TARGET_INFORMATIONW	TargetInformation,
		DWORD	Flags,
		DWORD *	Size,
		PCREDENTIALW **	Credentials
	)

Definition at line 1754 of file cred.c.

{
    FIXME("(%p, 0x%x, %p, %p) stub\n", TargetInformation, Flags, Size, Credentials);
 
    /* follow Windows behavior - do not test for NULL, initialize early */
    *Size = 0;
    *Credentials = NULL;
    if (!TargetInformation)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    SetLastError(ERROR_NOT_FOUND);
    return FALSE;
}

Referenced by CredReadDomainCredentialsA().

◆ CredReadW()

BOOL WINAPI CredReadW	(	LPCWSTR	TargetName,
		DWORD	Type,
		DWORD	Flags,
		PCREDENTIALW *	Credential
	)

Definition at line 1450 of file cred.c.

{
    HKEY hkeyMgr;
    HKEY hkeyCred;
    DWORD ret;
    LPWSTR key_name;
    DWORD len;
    BYTE key_data[KEY_SIZE];
 
    TRACE("(%s, %d, 0x%x, %p)\n", debugstr_w(TargetName), Type, Flags, Credential);
 
    if (!TargetName)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (Type != CRED_TYPE_GENERIC && Type != CRED_TYPE_DOMAIN_PASSWORD)
    {
        FIXME("unhandled type %d\n", Type);
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (Flags)
    {
        FIXME("unhandled flags 0x%x\n", Flags);
        SetLastError(ERROR_INVALID_FLAGS);
        return FALSE;
    }
 
#ifdef __APPLE__
    if (Type == CRED_TYPE_DOMAIN_PASSWORD)
    {
        int status;
        SecKeychainSearchRef search;
        status = SecKeychainSearchCreateFromAttributes(NULL, kSecGenericPasswordItemClass, NULL, &search);
        if (status == noErr)
        {
            SecKeychainItemRef item;
            while (SecKeychainSearchCopyNext(search, &item) == noErr)
            {
                SecKeychainAttributeInfo info;
                SecKeychainAttributeList *attr_list;
                UInt32 info_tags[] = { kSecServiceItemAttr };
                LPWSTR target_name;
                INT str_len;
                info.count = sizeof(info_tags)/sizeof(info_tags[0]);
                info.tag = info_tags;
                info.format = NULL;
                status = SecKeychainItemCopyAttributesAndData(item, &info, NULL, &attr_list, NULL, NULL);
                len = sizeof(**Credential);
                if (status != noErr)
                {
                    WARN("SecKeychainItemCopyAttributesAndData returned status %d\n", status);
                    continue;
                }
                if (attr_list->count != 1 || attr_list->attr[0].tag != kSecServiceItemAttr)
                {
                    CFRelease(item);
                    continue;
                }
                str_len = MultiByteToWideChar(CP_UTF8, 0, attr_list->attr[0].data, attr_list->attr[0].length, NULL, 0);
                target_name = heap_alloc((str_len + 1) * sizeof(WCHAR));
                MultiByteToWideChar(CP_UTF8, 0, attr_list->attr[0].data, attr_list->attr[0].length, target_name, str_len);
                /* nul terminate */
                target_name[str_len] = '\0';
                if (strcmpiW(TargetName, target_name))
                {
                    CFRelease(item);
                    heap_free(target_name);
                    continue;
                }
                heap_free(target_name);
                SecKeychainItemFreeAttributesAndData(attr_list, NULL);
                ret = mac_read_credential_from_item(item, TRUE, NULL, NULL, &len);
                if (ret == ERROR_SUCCESS)
                {
                    *Credential = heap_alloc(len);
                    if (*Credential)
                    {
                        len = sizeof(**Credential);
                        ret = mac_read_credential_from_item(item, TRUE, *Credential,
                                                            (char *)(*Credential + 1), &len);
                    }
                    else
                        ret = ERROR_OUTOFMEMORY;
                    CFRelease(item);
                    CFRelease(search);
                    if (ret != ERROR_SUCCESS)
                    {
                        SetLastError(ret);
                        return FALSE;
                    }
                    return TRUE;
                }
                CFRelease(item);
            }
            CFRelease(search);
        }
    }
#endif
 
    ret = open_cred_mgr_key(&hkeyMgr, FALSE);
    if (ret != ERROR_SUCCESS)
    {
        WARN("couldn't open/create manager key, error %d\n", ret);
        SetLastError(ERROR_NO_SUCH_LOGON_SESSION);
        return FALSE;
    }
 
    ret = get_cred_mgr_encryption_key(hkeyMgr, key_data);
    if (ret != ERROR_SUCCESS)
    {
        RegCloseKey(hkeyMgr);
        SetLastError(ret);
        return FALSE;
    }
 
    key_name = get_key_name_for_target(TargetName, Type);
    ret = RegOpenKeyExW(hkeyMgr, key_name, 0, KEY_QUERY_VALUE, &hkeyCred);
    heap_free(key_name);
    if (ret != ERROR_SUCCESS)
    {
        TRACE("credentials for target name %s not found\n", debugstr_w(TargetName));
        SetLastError(ERROR_NOT_FOUND);
        return FALSE;
    }
 
    len = sizeof(**Credential);
    ret = registry_read_credential(hkeyCred, NULL, key_data, NULL, &len);
    if (ret == ERROR_SUCCESS)
    {
        *Credential = heap_alloc(len);
        if (*Credential)
        {
            len = sizeof(**Credential);
            ret = registry_read_credential(hkeyCred, *Credential, key_data,
                                           (char *)(*Credential + 1), &len);
        }
        else
            ret = ERROR_OUTOFMEMORY;
    }
 
    RegCloseKey(hkeyCred);
    RegCloseKey(hkeyMgr);
 
    if (ret != ERROR_SUCCESS)
    {
        SetLastError(ret);
        return FALSE;
    }
    return TRUE;
}

Referenced by CredReadA(), and ntlm_GetCachedCredential().

◆ CredUnmarshalCredentialA()

BOOL WINAPI CredUnmarshalCredentialA	(	LPCSTR	cred,
		PCRED_MARSHAL_TYPE	type,
		PVOID *	out
	)

Definition at line 2049 of file cred.c.

{
    BOOL ret;
    WCHAR *credW = NULL;
 
    TRACE("%s, %p, %p\n", debugstr_a(cred), type, out);
 
    if (cred)
    {
        int len = MultiByteToWideChar( CP_ACP, 0, cred, -1, NULL, 0 );
        if (!(credW = heap_alloc( len * sizeof(WCHAR) ))) return FALSE;
        MultiByteToWideChar( CP_ACP, 0, cred, -1, credW, len );
    }
    ret = CredUnmarshalCredentialW( credW, type, out );
    heap_free( credW );
    return ret;
}

◆ CredUnmarshalCredentialW()

BOOL WINAPI CredUnmarshalCredentialW	(	LPCWSTR	cred,
		PCRED_MARSHAL_TYPE	type,
		PVOID *	out
	)

Definition at line 2123 of file cred.c.

{
    unsigned int len, buflen;
 
    TRACE("%s, %p, %p\n", debugstr_w(cred), type, out);
 
    if (!cred || cred[0] != '@' || cred[1] != '@' ||
        char_decode( cred[2] ) > 63)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    len = strlenW( cred + 3 );
    *type = char_decode( cred[2] );
    switch (*type)
    {
    case CertCredential:
    {
        char hash[CERT_HASH_LENGTH];
        CERT_CREDENTIAL_INFO *cert;
 
        if (len != 27 || !cred_decode( cred + 3, len, hash ))
        {
            SetLastError( ERROR_INVALID_PARAMETER );
            return FALSE;
        }
        if (!(cert = heap_alloc( sizeof(*cert) ))) return FALSE;
        memcpy( cert->rgbHashOfCert, hash, sizeof(cert->rgbHashOfCert) );
        cert->cbSize = sizeof(*cert);
        *out = cert;
        break;
    }
    case UsernameTargetCredential:
    {
        USERNAME_TARGET_CREDENTIAL_INFO *target;
        DWORD size;
 
        if (len < 9 || !cred_decode( cred + 3, 6, (char *)&size ) ||
            size % sizeof(WCHAR) || len - 6 != (size * 4 + 2) / 3)
        {
            SetLastError( ERROR_INVALID_PARAMETER );
            return FALSE;
        }
        buflen = sizeof(*target) + size + sizeof(WCHAR);
        if (!(target = heap_alloc( buflen ))) return FALSE;
        if (!cred_decode( cred + 9, len - 6, (char *)(target + 1) ))
        {
            heap_free( target );
            return FALSE;
        }
        target->UserName = (WCHAR *)(target + 1);
        target->UserName[size / sizeof(WCHAR)] = 0;
        *out = target;
        break;
    }
    case BinaryBlobCredential:
        FIXME("BinaryBlobCredential not implemented\n");
        return FALSE;
    default:
        WARN("unhandled type %u\n", *type);
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    return TRUE;
}

Referenced by CredUnmarshalCredentialA().

◆ CredWriteA()

BOOL WINAPI CredWriteA	(	PCREDENTIALA	Credential,
		DWORD	Flags
	)

Definition at line 1775 of file cred.c.

{
    BOOL ret;
    INT len;
    PCREDENTIALW CredentialW;
 
    TRACE("(%p, 0x%x)\n", Credential, Flags);
 
    if (!Credential || !Credential->TargetName)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    len = convert_PCREDENTIALA_to_PCREDENTIALW(Credential, NULL, 0);
    CredentialW = heap_alloc(len);
    if (!CredentialW)
    {
        SetLastError(ERROR_OUTOFMEMORY);
        return FALSE;
    }
 
    convert_PCREDENTIALA_to_PCREDENTIALW(Credential, CredentialW, len);
 
    ret = CredWriteW(CredentialW, Flags);
 
    heap_free(CredentialW);
 
    return ret;
}

◆ CredWriteW()

BOOL WINAPI CredWriteW	(	PCREDENTIALW	Credential,
		DWORD	Flags
	)

Definition at line 1809 of file cred.c.

{
    HKEY hkeyMgr;
    HKEY hkeyCred;
    DWORD ret;
    LPWSTR key_name;
    BYTE key_data[KEY_SIZE];
 
    TRACE("(%p, 0x%x)\n", Credential, Flags);
 
    if (!Credential || !Credential->TargetName)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (Flags & ~CRED_PRESERVE_CREDENTIAL_BLOB)
    {
        FIXME("unhandled flags 0x%x\n", Flags);
        SetLastError(ERROR_INVALID_FLAGS);
        return FALSE;
    }
 
    if (Credential->Type != CRED_TYPE_GENERIC && Credential->Type != CRED_TYPE_DOMAIN_PASSWORD)
    {
        FIXME("unhandled type %d\n", Credential->Type);
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    TRACE("Credential->Flags = 0x%08x\n", Credential->Flags);
    TRACE("Credential->Type = %u\n", Credential->Type);
    TRACE("Credential->TargetName = %s\n", debugstr_w(Credential->TargetName));
    TRACE("Credential->Comment = %s\n", debugstr_w(Credential->Comment));
    TRACE("Credential->Persist = %u\n", Credential->Persist);
    TRACE("Credential->TargetAlias = %s\n", debugstr_w(Credential->TargetAlias));
    TRACE("Credential->UserName = %s\n", debugstr_w(Credential->UserName));
 
    if (Credential->Type == CRED_TYPE_DOMAIN_PASSWORD)
    {
        if (!Credential->UserName ||
            (Credential->Persist == CRED_PERSIST_ENTERPRISE &&
            (!strchrW(Credential->UserName, '\\') && !strchrW(Credential->UserName, '@'))))
        {
            ERR("bad username %s\n", debugstr_w(Credential->UserName));
            SetLastError(ERROR_BAD_USERNAME);
            return FALSE;
        }
    }
 
#ifdef __APPLE__
    if (!Credential->AttributeCount &&
        Credential->Type == CRED_TYPE_DOMAIN_PASSWORD &&
        (Credential->Persist == CRED_PERSIST_LOCAL_MACHINE || Credential->Persist == CRED_PERSIST_ENTERPRISE))
    {
        ret = mac_write_credential(Credential, Flags & CRED_PRESERVE_CREDENTIAL_BLOB);
        if (ret != ERROR_SUCCESS)
        {
            SetLastError(ret);
            return FALSE;
        }
        return TRUE;
    }
#endif
 
    ret = open_cred_mgr_key(&hkeyMgr, FALSE);
    if (ret != ERROR_SUCCESS)
    {
        WARN("couldn't open/create manager key, error %d\n", ret);
        SetLastError(ERROR_NO_SUCH_LOGON_SESSION);
        return FALSE;
    }
 
    ret = get_cred_mgr_encryption_key(hkeyMgr, key_data);
    if (ret != ERROR_SUCCESS)
    {
        RegCloseKey(hkeyMgr);
        SetLastError(ret);
        return FALSE;
    }
 
    key_name = get_key_name_for_target(Credential->TargetName, Credential->Type);
    ret = RegCreateKeyExW(hkeyMgr, key_name, 0, NULL,
                          Credential->Persist == CRED_PERSIST_SESSION ? REG_OPTION_VOLATILE : REG_OPTION_NON_VOLATILE,
                          KEY_READ|KEY_WRITE, NULL, &hkeyCred, NULL);
    heap_free(key_name);
    if (ret != ERROR_SUCCESS)
    {
        TRACE("credentials for target name %s not found\n",
              debugstr_w(Credential->TargetName));
        SetLastError(ERROR_NOT_FOUND);
        return FALSE;
    }
 
    ret = registry_write_credential(hkeyCred, Credential, key_data,
                                    Flags & CRED_PRESERVE_CREDENTIAL_BLOB);
 
    RegCloseKey(hkeyCred);
    RegCloseKey(hkeyMgr);
 
    if (ret != ERROR_SUCCESS)
    {
        SetLastError(ret);
        return FALSE;
    }
    return TRUE;
}

Referenced by CredWriteA(), and save_credentials().

◆ get_cred_mgr_encryption_key()

static DWORD get_cred_mgr_encryption_key	(	HKEY	hkeyMgr,
		BYTE	key_data[KEY_SIZE]
	)

static

Definition at line 639 of file cred.c.

{
    static const BYTE my_key_data[KEY_SIZE] = { 0 };
    DWORD type;
    DWORD count;
    FILETIME ft;
    ULONG seed;
    ULONG value;
    DWORD ret;
 
    memcpy(key_data, my_key_data, KEY_SIZE);
 
    count = KEY_SIZE;
    ret = RegQueryValueExW(hkeyMgr, wszEncryptionKeyValue, NULL, &type, key_data,
                           &count);
    if (ret == ERROR_SUCCESS)
    {
        if (type != REG_BINARY)
            return ERROR_REGISTRY_CORRUPT;
        else
            return ERROR_SUCCESS;
    }
    if (ret != ERROR_FILE_NOT_FOUND)
        return ret;
 
    GetSystemTimeAsFileTime(&ft);
    seed = ft.dwLowDateTime;
    value = RtlUniform(&seed);
    *(DWORD *)key_data = value;
    seed = ft.dwHighDateTime;
    value = RtlUniform(&seed);
    *(DWORD *)(key_data + 4) = value;
 
    ret = RegSetValueExW(hkeyMgr, wszEncryptionKeyValue, 0, REG_BINARY,
                         key_data, KEY_SIZE);
    if (ret == ERROR_ACCESS_DENIED)
    {
        ret = open_cred_mgr_key(&hkeyMgr, TRUE);
        if (ret == ERROR_SUCCESS)
        {
            ret = RegSetValueExW(hkeyMgr, wszEncryptionKeyValue, 0, REG_BINARY,
                                 key_data, KEY_SIZE);
            RegCloseKey(hkeyMgr);
        }
    }
    return ret;
}

Referenced by CredEnumerateW(), CredReadW(), and CredWriteW().

◆ get_key_name_for_target()

static LPWSTR get_key_name_for_target	(	LPCWSTR	target_name,
		DWORD	type
	)

static

Definition at line 687 of file cred.c.

{
    static const WCHAR wszGenericPrefix[] = {'G','e','n','e','r','i','c',':',' ',0};
    static const WCHAR wszDomPasswdPrefix[] = {'D','o','m','P','a','s','s','w','d',':',' ',0};
    INT len;
    LPCWSTR prefix = NULL;
    LPWSTR key_name, p;
 
    len = strlenW(target_name);
    if (type == CRED_TYPE_GENERIC)
    {
        prefix = wszGenericPrefix;
        len += sizeof(wszGenericPrefix)/sizeof(wszGenericPrefix[0]);
    }
    else
    {
        prefix = wszDomPasswdPrefix;
        len += sizeof(wszDomPasswdPrefix)/sizeof(wszDomPasswdPrefix[0]);
    }
 
    key_name = heap_alloc(len * sizeof(WCHAR));
    if (!key_name) return NULL;
 
    strcpyW(key_name, prefix);
    strcatW(key_name, target_name);
 
    for (p = key_name; *p; p++)
        if (*p == '\\') *p = '_';
 
    return key_name;
}

Referenced by CredDeleteW(), CredReadW(), and CredWriteW().

◆ open_cred_mgr_key()

static DWORD open_cred_mgr_key	(	HKEY *	hkey,
		BOOL	open_for_write
	)

static

Definition at line 632 of file cred.c.

{
    return RegCreateKeyExW(HKEY_CURRENT_USER, wszCredentialManagerKey, 0,
                           NULL, REG_OPTION_NON_VOLATILE,
                           KEY_READ | (open_for_write ? KEY_WRITE : 0), NULL, hkey, NULL);
}

Referenced by CredDeleteW(), CredEnumerateW(), CredReadW(), CredWriteW(), and get_cred_mgr_encryption_key().

◆ read_credential_blob()

static DWORD read_credential_blob	(	HKEY	hkey,
		const BYTE	key_data[KEY_SIZE],
		LPBYTE	credential_blob,
		DWORD *	credential_blob_size
	)

static

Definition at line 68 of file cred.c.

{
    DWORD ret;
    DWORD type;
 
    *credential_blob_size = 0;
    ret = RegQueryValueExW(hkey, wszPasswordValue, 0, &type, NULL, credential_blob_size);
    if (ret != ERROR_SUCCESS)
        return ret;
    else if (type != REG_BINARY)
        return ERROR_REGISTRY_CORRUPT;
    if (credential_blob)
    {
        struct ustring data;
        struct ustring key;
 
        ret = RegQueryValueExW(hkey, wszPasswordValue, 0, &type, credential_blob,
                               credential_blob_size);
        if (ret != ERROR_SUCCESS)
            return ret;
        else if (type != REG_BINARY)
            return ERROR_REGISTRY_CORRUPT;
 
        key.Length = key.MaximumLength = KEY_SIZE;
        key.Buffer = (unsigned char *)key_data;
 
        data.Length = data.MaximumLength = *credential_blob_size;
        data.Buffer = credential_blob;
        SystemFunction032(&data, &key);
    }
    return ERROR_SUCCESS;
}

Referenced by registry_read_credential().

◆ registry_credential_matches_filter()

static BOOL registry_credential_matches_filter	(	HKEY	hkeyCred,
		LPCWSTR	filter
	)

static

Definition at line 719 of file cred.c.

{
    LPWSTR target_name;
    DWORD ret;
    DWORD type;
    DWORD count;
    LPCWSTR p;
 
    if (!filter) return TRUE;
 
    ret = RegQueryValueExW(hkeyCred, NULL, 0, &type, NULL, &count);
    if (ret != ERROR_SUCCESS)
        return FALSE;
    else if (type != REG_SZ)
        return FALSE;
 
    target_name = heap_alloc(count);
    if (!target_name)
        return FALSE;
    ret = RegQueryValueExW(hkeyCred, NULL, 0, &type, (LPVOID)target_name, &count);
    if (ret != ERROR_SUCCESS || type != REG_SZ)
    {
        heap_free(target_name);
        return FALSE;
    }
 
    TRACE("comparing filter %s to target name %s\n", debugstr_w(filter),
          debugstr_w(target_name));
 
    p = strchrW(filter, '*');
    ret = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, filter,
                         (p && !p[1] ? p - filter : -1), target_name,
                         (p && !p[1] ? p - filter : -1)) == CSTR_EQUAL;
 
    heap_free(target_name);
    return ret;
}

Referenced by registry_enumerate_credentials().

◆ registry_enumerate_credentials()

static DWORD registry_enumerate_credentials	(	HKEY	hkeyMgr,
		LPCWSTR	filter,
		LPWSTR	target_name,
		DWORD	target_name_len,
		const BYTE	key_data[KEY_SIZE],
		PCREDENTIALW *	credentials,
		char **	buffer,
		DWORD *	len,
		DWORD *	count
	)

static

Definition at line 757 of file cred.c.

{
    DWORD i;
    DWORD ret;
    for (i = 0;; i++)
    {
        HKEY hkeyCred;
        ret = RegEnumKeyW(hkeyMgr, i, target_name, target_name_len+1);
        if (ret == ERROR_NO_MORE_ITEMS)
        {
            ret = ERROR_SUCCESS;
            break;
        }
        else if (ret != ERROR_SUCCESS)
            continue;
        TRACE("target_name = %s\n", debugstr_w(target_name));
        ret = RegOpenKeyExW(hkeyMgr, target_name, 0, KEY_QUERY_VALUE, &hkeyCred);
        if (ret != ERROR_SUCCESS)
            continue;
        if (!registry_credential_matches_filter(hkeyCred, filter))
        {
            RegCloseKey(hkeyCred);
            continue;
        }
        if (buffer)
        {
            *len = sizeof(CREDENTIALW);
            credentials[*count] = (PCREDENTIALW)*buffer;
        }
        else
            *len += sizeof(CREDENTIALW);
        ret = registry_read_credential(hkeyCred, buffer ? credentials[*count] : NULL,
                                       key_data, buffer ? *buffer + sizeof(CREDENTIALW) : NULL,
                                       len);
        RegCloseKey(hkeyCred);
        if (ret != ERROR_SUCCESS) break;
        if (buffer) *buffer += *len;
        (*count)++;
    }
    return ret;
}

Referenced by CredEnumerateW().

◆ registry_read_credential()

static DWORD registry_read_credential	(	HKEY	hkey,
		PCREDENTIALW	credential,
		const BYTE	key_data[KEY_SIZE],
		char *	buffer,
		DWORD *	len
	)

static

Definition at line 103 of file cred.c.

{
    DWORD type;
    DWORD ret;
    DWORD count;
 
    ret = RegQueryValueExW(hkey, NULL, 0, &type, NULL, &count);
    if (ret != ERROR_SUCCESS)
        return ret;
    else if (type != REG_SZ)
        return ERROR_REGISTRY_CORRUPT;
    *len += count;
    if (credential)
    {
        credential->TargetName = (LPWSTR)buffer;
        ret = RegQueryValueExW(hkey, NULL, 0, &type, (LPVOID)credential->TargetName,
                               &count);
#ifdef __REACTOS__
        if (ret != ERROR_SUCCESS)
            return ret;
        else if (type != REG_SZ)
            return ERROR_REGISTRY_CORRUPT;
#else
        if (ret != ERROR_SUCCESS || type != REG_SZ) return ret;
#endif
        buffer += count;
    }
 
    ret = RegQueryValueExW(hkey, wszCommentValue, 0, &type, NULL, &count);
#ifdef __REACTOS__
    if (ret != ERROR_FILE_NOT_FOUND)
    {
        if (ret != ERROR_SUCCESS)
            return ret;
        else if (type != REG_SZ)
            return ERROR_REGISTRY_CORRUPT;
        *len += count;
    }
#else
    if (ret != ERROR_FILE_NOT_FOUND && ret != ERROR_SUCCESS)
        return ret;
    else if (type != REG_SZ)
        return ERROR_REGISTRY_CORRUPT;
    *len += count;
#endif
    if (credential)
    {
        credential->Comment = (LPWSTR)buffer;
        ret = RegQueryValueExW(hkey, wszCommentValue, 0, &type, (LPVOID)credential->Comment,
                               &count);
        if (ret == ERROR_FILE_NOT_FOUND)
            credential->Comment = NULL;
        else if (ret != ERROR_SUCCESS)
            return ret;
        else if (type != REG_SZ)
            return ERROR_REGISTRY_CORRUPT;
        else
            buffer += count;
    }
 
    ret = RegQueryValueExW(hkey, wszTargetAliasValue, 0, &type, NULL, &count);
#ifdef __REACTOS__
    if (ret != ERROR_FILE_NOT_FOUND)
    {
        if (ret != ERROR_SUCCESS)
            return ret;
        else if (type != REG_SZ)
            return ERROR_REGISTRY_CORRUPT;
        *len += count;
    }
#else
    if (ret != ERROR_FILE_NOT_FOUND && ret != ERROR_SUCCESS)
        return ret;
    else if (type != REG_SZ)
        return ERROR_REGISTRY_CORRUPT;
    *len += count;
#endif
    if (credential)
    {
        credential->TargetAlias = (LPWSTR)buffer;
        ret = RegQueryValueExW(hkey, wszTargetAliasValue, 0, &type, (LPVOID)credential->TargetAlias,
                               &count);
        if (ret == ERROR_FILE_NOT_FOUND)
            credential->TargetAlias = NULL;
        else if (ret != ERROR_SUCCESS)
            return ret;
        else if (type != REG_SZ)
            return ERROR_REGISTRY_CORRUPT;
        else
            buffer += count;
    }
 
    ret = RegQueryValueExW(hkey, wszUserNameValue, 0, &type, NULL, &count);
#ifdef __REACTOS__
    if (ret != ERROR_FILE_NOT_FOUND)
    {
        if (ret != ERROR_SUCCESS)
            return ret;
        else if (type != REG_SZ)
            return ERROR_REGISTRY_CORRUPT;
        *len += count;
    }
#else
    if (ret != ERROR_FILE_NOT_FOUND && ret != ERROR_SUCCESS)
        return ret;
    else if (type != REG_SZ)
        return ERROR_REGISTRY_CORRUPT;
    *len += count;
#endif
    if (credential)
    {
        credential->UserName = (LPWSTR)buffer;
        ret = RegQueryValueExW(hkey, wszUserNameValue, 0, &type, (LPVOID)credential->UserName,
                               &count);
        if (ret == ERROR_FILE_NOT_FOUND)
            credential->UserName = NULL;
        else if (ret != ERROR_SUCCESS)
            return ret;
        else if (type != REG_SZ)
            return ERROR_REGISTRY_CORRUPT;
        else
            buffer += count;
    }
 
    ret = read_credential_blob(hkey, key_data, NULL, &count);
#ifdef __REACTOS__
    if (ret != ERROR_FILE_NOT_FOUND)
    {
        if (ret != ERROR_SUCCESS)
            return ret;
        *len += count;
    }
#else
    if (ret != ERROR_FILE_NOT_FOUND && ret != ERROR_SUCCESS)
        return ret;
    *len += count;
#endif
    if (credential)
    {
        credential->CredentialBlob = (LPBYTE)buffer;
        ret = read_credential_blob(hkey, key_data, credential->CredentialBlob, &count);
        if (ret == ERROR_FILE_NOT_FOUND)
            credential->CredentialBlob = NULL;
        else if (ret != ERROR_SUCCESS)
            return ret;
        credential->CredentialBlobSize = count;
    }
 
    /* FIXME: Attributes */
    if (credential)
    {
        credential->AttributeCount = 0;
        credential->Attributes = NULL;
    }
 
    if (!credential) return ERROR_SUCCESS;
 
    count = sizeof(credential->Flags);
    ret = RegQueryValueExW(hkey, wszFlagsValue, NULL, &type, (LPVOID)&credential->Flags,
                           &count);
    if (ret != ERROR_SUCCESS)
        return ret;
    else if (type != REG_DWORD)
        return ERROR_REGISTRY_CORRUPT;
    count = sizeof(credential->Type);
    ret = RegQueryValueExW(hkey, wszTypeValue, NULL, &type, (LPVOID)&credential->Type,
                           &count);
    if (ret != ERROR_SUCCESS)
        return ret;
    else if (type != REG_DWORD)
        return ERROR_REGISTRY_CORRUPT;
 
    count = sizeof(credential->LastWritten);
    ret = RegQueryValueExW(hkey, wszLastWrittenValue, NULL, &type, (LPVOID)&credential->LastWritten,
                           &count);
    if (ret != ERROR_SUCCESS)
        return ret;
    else if (type != REG_BINARY)
        return ERROR_REGISTRY_CORRUPT;
    count = sizeof(credential->Persist);
    ret = RegQueryValueExW(hkey, wszPersistValue, NULL, &type, (LPVOID)&credential->Persist,
                           &count);
    if (ret == ERROR_SUCCESS && type != REG_DWORD)
        return ERROR_REGISTRY_CORRUPT;
    return ret;
}

Referenced by CredReadW(), and registry_enumerate_credentials().

◆ registry_write_credential()

static DWORD registry_write_credential	(	HKEY	hkey,
		const CREDENTIALW *	credential,
		const BYTE	key_data[KEY_SIZE],
		BOOL	preserve_blob
	)

static

Definition at line 501 of file cred.c.

{
    DWORD ret;
    FILETIME LastWritten;
 
    GetSystemTimeAsFileTime(&LastWritten);
 
    ret = RegSetValueExW(hkey, wszFlagsValue, 0, REG_DWORD, (const BYTE*)&credential->Flags,
                         sizeof(credential->Flags));
    if (ret != ERROR_SUCCESS) return ret;
    ret = RegSetValueExW(hkey, wszTypeValue, 0, REG_DWORD, (const BYTE*)&credential->Type,
                         sizeof(credential->Type));
    if (ret != ERROR_SUCCESS) return ret;
    ret = RegSetValueExW(hkey, NULL, 0, REG_SZ, (LPVOID)credential->TargetName,
                         sizeof(WCHAR)*(strlenW(credential->TargetName)+1));
    if (ret != ERROR_SUCCESS) return ret;
    if (credential->Comment)
    {
        ret = RegSetValueExW(hkey, wszCommentValue, 0, REG_SZ, (LPVOID)credential->Comment,
                             sizeof(WCHAR)*(strlenW(credential->Comment)+1));
        if (ret != ERROR_SUCCESS) return ret;
    }
    ret = RegSetValueExW(hkey, wszLastWrittenValue, 0, REG_BINARY, (LPVOID)&LastWritten,
                         sizeof(LastWritten));
    if (ret != ERROR_SUCCESS) return ret;
    ret = RegSetValueExW(hkey, wszPersistValue, 0, REG_DWORD, (const BYTE*)&credential->Persist,
                         sizeof(credential->Persist));
    if (ret != ERROR_SUCCESS) return ret;
    /* FIXME: Attributes */
    if (credential->TargetAlias)
    {
        ret = RegSetValueExW(hkey, wszTargetAliasValue, 0, REG_SZ, (LPVOID)credential->TargetAlias,
                             sizeof(WCHAR)*(strlenW(credential->TargetAlias)+1));
        if (ret != ERROR_SUCCESS) return ret;
    }
    if (credential->UserName)
    {
        ret = RegSetValueExW(hkey, wszUserNameValue, 0, REG_SZ, (LPVOID)credential->UserName,
                             sizeof(WCHAR)*(strlenW(credential->UserName)+1));
        if (ret != ERROR_SUCCESS) return ret;
    }
    if (!preserve_blob)
    {
        ret = write_credential_blob(hkey, credential->TargetName, credential->Type,
                                    key_data, credential->CredentialBlob,
                                    credential->CredentialBlobSize);
    }
    return ret;
}

Referenced by CredWriteW().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( cred )

◆ write_credential_blob()

static DWORD write_credential_blob	(	HKEY	hkey,
		LPCWSTR	target_name,
		DWORD	type,
		const BYTE	key_data[KEY_SIZE],
		const BYTE *	credential_blob,
		DWORD	credential_blob_size
	)

static

Definition at line 475 of file cred.c.

{
    LPBYTE encrypted_credential_blob;
    struct ustring data;
    struct ustring key;
    DWORD ret;
 
    key.Length = key.MaximumLength = KEY_SIZE;
    key.Buffer = (unsigned char *)key_data;
 
    encrypted_credential_blob = heap_alloc(credential_blob_size);
    if (!encrypted_credential_blob) return ERROR_OUTOFMEMORY;
 
    memcpy(encrypted_credential_blob, credential_blob, credential_blob_size);
    data.Length = data.MaximumLength = credential_blob_size;
    data.Buffer = encrypted_credential_blob;
    SystemFunction032(&data, &key);
 
    ret = RegSetValueExW(hkey, wszPasswordValue, 0, REG_BINARY, encrypted_credential_blob, credential_blob_size);
    heap_free(encrypted_credential_blob);
 
    return ret;
}

Referenced by registry_write_credential().

Variable Documentation

◆ wszCommentValue

const WCHAR wszCommentValue[] = {'C','o','m','m','e','n','t',0}

static

Definition at line 61 of file cred.c.

Referenced by registry_read_credential(), and registry_write_credential().

◆ wszCredentialManagerKey

const WCHAR wszCredentialManagerKey[]

static

Initial value:

= {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',

'C','r','e','d','e','n','t','i','a','l',' ','M','a','n','a','g','e','r',0}

Definition at line 55 of file cred.c.

Referenced by open_cred_mgr_key().

◆ wszEncryptionKeyValue

const WCHAR wszEncryptionKeyValue[] = {'E','n','c','r','y','p','t','i','o','n','K','e','y',0}

static

Definition at line 57 of file cred.c.

Referenced by get_cred_mgr_encryption_key().

◆ wszFlagsValue

const WCHAR wszFlagsValue[] = {'F','l','a','g','s',0}

static

Definition at line 59 of file cred.c.

Referenced by registry_read_credential(), and registry_write_credential().

◆ wszLastWrittenValue

const WCHAR wszLastWrittenValue[] = {'L','a','s','t','W','r','i','t','t','e','n',0}

static

Definition at line 62 of file cred.c.

Referenced by registry_read_credential(), and registry_write_credential().

◆ wszPasswordValue

const WCHAR wszPasswordValue[] = {'P','a','s','s','w','o','r','d',0}

static

Definition at line 66 of file cred.c.

Referenced by read_credential_blob(), and write_credential_blob().

◆ wszPersistValue

const WCHAR wszPersistValue[] = {'P','e','r','s','i','s','t',0}

static

Definition at line 63 of file cred.c.

Referenced by registry_read_credential(), and registry_write_credential().

◆ wszTargetAliasValue

const WCHAR wszTargetAliasValue[] = {'T','a','r','g','e','t','A','l','i','a','s',0}

static

Definition at line 64 of file cred.c.

Referenced by registry_read_credential(), and registry_write_credential().

◆ wszTypeValue

const WCHAR wszTypeValue[] = {'T','y','p','e',0}

static

Definition at line 60 of file cred.c.

Referenced by registry_read_credential(), and registry_write_credential().

◆ wszUserNameValue

const WCHAR wszUserNameValue[] = {'U','s','e','r','N','a','m','e',0}

static

Definition at line 65 of file cred.c.

Referenced by registry_read_credential(), and registry_write_credential().

Macros

Functions

Variables

Macro Definition Documentation

◆ KEY_SIZE

Function Documentation

◆ char_decode()

◆ convert_PCREDENTIALA_to_PCREDENTIALW()

◆ convert_PCREDENTIALW_to_PCREDENTIALA()

◆ cred_decode()

◆ cred_encode()

◆ CredDeleteA()

◆ CredDeleteW()

◆ CredEnumerateA()

◆ CredEnumerateW()

◆ CredFree()

◆ CredGetSessionTypes()

◆ CredIsMarshaledCredentialA()

◆ CredIsMarshaledCredentialW()

◆ CredMarshalCredentialA()

◆ CredMarshalCredentialW()

◆ CredReadA()

◆ CredReadDomainCredentialsA()

◆ CredReadDomainCredentialsW()

◆ CredReadW()

◆ CredUnmarshalCredentialA()

◆ CredUnmarshalCredentialW()

◆ CredWriteA()

◆ CredWriteW()

◆ get_cred_mgr_encryption_key()

◆ get_key_name_for_target()

◆ open_cred_mgr_key()

◆ read_credential_blob()

◆ registry_credential_matches_filter()

◆ registry_enumerate_credentials()

◆ registry_read_credential()

◆ registry_write_credential()

◆ WINE_DEFAULT_DEBUG_CHANNEL()

◆ write_credential_blob()

Variable Documentation

◆ wszCommentValue

◆ wszCredentialManagerKey

◆ wszEncryptionKeyValue

◆ wszFlagsValue

◆ wszLastWrittenValue

◆ wszPasswordValue

◆ wszPersistValue

◆ wszTargetAliasValue

◆ wszTypeValue

◆ wszUserNameValue