dlls/advapi32/cred.c

   1 /*
   2  * Credential Management APIs
   3  *
   4  * Copyright 2007 Robert Shearman for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include <time.h>
  23 #include <limits.h>
  24
  25 #ifdef __APPLE__
  26 # include <Security/SecKeychain.h>
  27 # include <Security/SecKeychainItem.h>
  28 # include <Security/SecKeychainSearch.h>
  29 #endif
  30
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "winreg.h"
  34 #include "wincred.h"
  35 #include "winternl.h"
  36
  37 #include "crypt.h"
  38
  39 #include "wine/unicode.h"
  40 #include "wine/debug.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(cred);
  43
  44 /* the size of the ARC4 key used to encrypt the password data */
  45 #define KEY_SIZE 8
  46
  47 static const WCHAR wszCredentialManagerKey[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
  48     'C','r','e','d','e','n','t','i','a','l',' ','M','a','n','a','g','e','r',0};
  49 static const WCHAR wszEncryptionKeyValue[] = {'E','n','c','r','y','p','t','i','o','n','K','e','y',0};
  50
  51 static const WCHAR wszFlagsValue[] = {'F','l','a','g','s',0};
  52 static const WCHAR wszTypeValue[] = {'T','y','p','e',0};
  53 static const WCHAR wszCommentValue[] = {'C','o','m','m','e','n','t',0};
  54 static const WCHAR wszLastWrittenValue[] = {'L','a','s','t','W','r','i','t','t','e','n',0};
  55 static const WCHAR wszPersistValue[] = {'P','e','r','s','i','s','t',0};
  56 static const WCHAR wszTargetAliasValue[] = {'T','a','r','g','e','t','A','l','i','a','s',0};
  57 static const WCHAR wszUserNameValue[] = {'U','s','e','r','N','a','m','e',0};
  58 static const WCHAR wszPasswordValue[] = {'P','a','s','s','w','o','r','d',0};
  59
  60 static DWORD read_credential_blob(HKEY hkey, const BYTE key_data[KEY_SIZE],
  61                                   LPBYTE credential_blob,
  62                                   DWORD *credential_blob_size)
  63 {
  64     DWORD ret;
  65     DWORD type;
  66
  67     *credential_blob_size = 0;
  68     ret = RegQueryValueExW(hkey, wszPasswordValue, 0, &type, NULL, credential_blob_size);
  69     if (ret != ERROR_SUCCESS)
  70         return ret;
  71     else if (type != REG_BINARY)
  72         return ERROR_REGISTRY_CORRUPT;
  73     if (credential_blob)
  74     {
  75         struct ustring data;
  76         struct ustring key;
  77
  78         ret = RegQueryValueExW(hkey, wszPasswordValue, 0, &type, credential_blob,
  79                                credential_blob_size);
  80         if (ret != ERROR_SUCCESS)
  81             return ret;
  82         else if (type != REG_BINARY)
  83             return ERROR_REGISTRY_CORRUPT;
  84
  85         key.Length = key.MaximumLength = KEY_SIZE;
  86         key.Buffer = (unsigned char *)key_data;
  87
  88         data.Length = data.MaximumLength = *credential_blob_size;
  89         data.Buffer = credential_blob;
  90         SystemFunction032(&data, &key);
  91     }
  92     return ERROR_SUCCESS;
  93 }
  94
  95 static DWORD registry_read_credential(HKEY hkey, PCREDENTIALW credential,
  96                                       const BYTE key_data[KEY_SIZE],
  97                                       char *buffer, DWORD *len)
  98 {
  99     DWORD type;
 100     DWORD ret;
 101     DWORD count;
 102
 103     ret = RegQueryValueExW(hkey, NULL, 0, &type, NULL, &count);
 104     if (ret != ERROR_SUCCESS)
 105         return ret;
 106     else if (type != REG_SZ)
 107         return ERROR_REGISTRY_CORRUPT;
 108     *len += count;
 109     if (credential)
 110     {
 111         credential->TargetName = (LPWSTR)buffer;
 112         ret = RegQueryValueExW(hkey, NULL, 0, &type, (LPVOID)credential->TargetName,
 113                                &count);
 114         if (ret != ERROR_SUCCESS || type != REG_SZ) return ret;
 115         buffer += count;
 116     }
 117
 118     ret = RegQueryValueExW(hkey, wszCommentValue, 0, &type, NULL, &count);
 119     if (ret != ERROR_FILE_NOT_FOUND && ret != ERROR_SUCCESS)
 120         return ret;
 121     else if (type != REG_SZ)
 122         return ERROR_REGISTRY_CORRUPT;
 123     *len += count;
 124     if (credential)
 125     {
 126         credential->Comment = (LPWSTR)buffer;
 127         ret = RegQueryValueExW(hkey, wszCommentValue, 0, &type, (LPVOID)credential->Comment,
 128                                &count);
 129         if (ret == ERROR_FILE_NOT_FOUND)
 130             credential->Comment = NULL;
 131         else if (ret != ERROR_SUCCESS)
 132             return ret;
 133         else if (type != REG_SZ)
 134             return ERROR_REGISTRY_CORRUPT;
 135         else
 136             buffer += count;
 137     }
 138
 139     ret = RegQueryValueExW(hkey, wszTargetAliasValue, 0, &type, NULL, &count);
 140     if (ret != ERROR_FILE_NOT_FOUND && ret != ERROR_SUCCESS)
 141         return ret;
 142     else if (type != REG_SZ)
 143         return ERROR_REGISTRY_CORRUPT;
 144     *len += count;
 145     if (credential)
 146     {
 147         credential->TargetAlias = (LPWSTR)buffer;
 148         ret = RegQueryValueExW(hkey, wszTargetAliasValue, 0, &type, (LPVOID)credential->TargetAlias,
 149                                &count);
 150         if (ret == ERROR_FILE_NOT_FOUND)
 151             credential->TargetAlias = NULL;
 152         else if (ret != ERROR_SUCCESS)
 153             return ret;
 154         else if (type != REG_SZ)
 155             return ERROR_REGISTRY_CORRUPT;
 156         else
 157             buffer += count;
 158     }
 159
 160     ret = RegQueryValueExW(hkey, wszUserNameValue, 0, &type, NULL, &count);
 161     if (ret != ERROR_FILE_NOT_FOUND && ret != ERROR_SUCCESS)
 162         return ret;
 163     else if (type != REG_SZ)
 164         return ERROR_REGISTRY_CORRUPT;
 165     *len += count;
 166     if (credential)
 167     {
 168         credential->UserName = (LPWSTR)buffer;
 169         ret = RegQueryValueExW(hkey, wszUserNameValue, 0, &type, (LPVOID)credential->UserName,
 170                                &count);
 171         if (ret == ERROR_FILE_NOT_FOUND)
 172             credential->UserName = NULL;
 173         else if (ret != ERROR_SUCCESS)
 174             return ret;
 175         else if (type != REG_SZ)
 176             return ERROR_REGISTRY_CORRUPT;
 177         else
 178             buffer += count;
 179     }
 180
 181     ret = read_credential_blob(hkey, key_data, NULL, &count);
 182     if (ret != ERROR_FILE_NOT_FOUND && ret != ERROR_SUCCESS)
 183         return ret;
 184     *len += count;
 185     if (credential)
 186     {
 187         credential->CredentialBlob = (LPBYTE)buffer;
 188         ret = read_credential_blob(hkey, key_data, credential->CredentialBlob, &count);
 189         if (ret == ERROR_FILE_NOT_FOUND)
 190             credential->CredentialBlob = NULL;
 191         else if (ret != ERROR_SUCCESS)
 192             return ret;
 193         credential->CredentialBlobSize = count;
 194     }
 195
 196     /* FIXME: Attributes */
 197     if (credential)
 198     {
 199         credential->AttributeCount = 0;
 200         credential->Attributes = NULL;
 201     }
 202
 203     if (!credential) return ERROR_SUCCESS;
 204
 205     count = sizeof(credential->Flags);
 206     ret = RegQueryValueExW(hkey, wszFlagsValue, NULL, &type, (LPVOID)&credential->Flags,
 207                            &count);
 208     if (ret != ERROR_SUCCESS)
 209         return ret;
 210     else if (type != REG_DWORD)
 211         return ERROR_REGISTRY_CORRUPT;
 212     count = sizeof(credential->Type);
 213     ret = RegQueryValueExW(hkey, wszTypeValue, NULL, &type, (LPVOID)&credential->Type,
 214                            &count);
 215     if (ret != ERROR_SUCCESS)
 216         return ret;
 217     else if (type != REG_DWORD)
 218         return ERROR_REGISTRY_CORRUPT;
 219
 220     count = sizeof(credential->LastWritten);
 221     ret = RegQueryValueExW(hkey, wszLastWrittenValue, NULL, &type, (LPVOID)&credential->LastWritten,
 222                            &count);
 223     if (ret != ERROR_SUCCESS)
 224         return ret;
 225     else if (type != REG_BINARY)
 226         return ERROR_REGISTRY_CORRUPT;
 227     count = sizeof(credential->Persist);
 228     ret = RegQueryValueExW(hkey, wszPersistValue, NULL, &type, (LPVOID)&credential->Persist,
 229                            &count);
 230     if (ret == ERROR_SUCCESS && type != REG_DWORD)
 231         return ERROR_REGISTRY_CORRUPT;
 232     return ret;
 233 }
 234
 235 #ifdef __APPLE__
 236 static DWORD mac_read_credential_from_item(SecKeychainItemRef item, BOOL require_password,
 237                                            PCREDENTIALW credential, char *buffer,
 238                                            DWORD *len)
 239 {
 240     OSStatus status;
 241     UInt32 i, cred_blob_len;
 242     void *cred_blob;
 243     WCHAR *user = NULL;
 244     BOOL user_name_present = FALSE;
 245     SecKeychainAttributeInfo info;
 246     SecKeychainAttributeList *attr_list;
 247     UInt32 info_tags[] = { kSecServiceItemAttr, kSecAccountItemAttr,
 248                            kSecCommentItemAttr, kSecCreationDateItemAttr };
 249     info.count = sizeof(info_tags)/sizeof(info_tags[0]);
 250     info.tag = info_tags;
 251     info.format = NULL;
 252     status = SecKeychainItemCopyAttributesAndData(item, &info, NULL, &attr_list, &cred_blob_len, &cred_blob);
 253     if (status == errSecAuthFailed && !require_password)
 254     {
 255         cred_blob_len = 0;
 256         cred_blob = NULL;
 257         status = SecKeychainItemCopyAttributesAndData(item, &info, NULL, &attr_list, &cred_blob_len, NULL);
 258     }
 259     if (status != noErr)
 260     {
 261         WARN("SecKeychainItemCopyAttributesAndData returned status %ld\n", status);
 262         return ERROR_NOT_FOUND;
 263     }
 264
 265     for (i = 0; i < attr_list->count; i++)
 266         if (attr_list->attr[i].tag == kSecAccountItemAttr && attr_list->attr[i].data)
 267         {
 268             user_name_present = TRUE;
 269             break;
 270         }
 271     if (!user_name_present)
 272     {
 273         WARN("no kSecAccountItemAttr for item\n");
 274         SecKeychainItemFreeAttributesAndData(attr_list, cred_blob);
 275         return ERROR_NOT_FOUND;
 276     }
 277
 278     if (buffer)
 279     {
 280         credential->Flags = 0;
 281         credential->Type = CRED_TYPE_DOMAIN_PASSWORD;
 282         credential->TargetName = NULL;
 283         credential->Comment = NULL;
 284         memset(&credential->LastWritten, 0, sizeof(credential->LastWritten));
 285         credential->CredentialBlobSize = 0;
 286         credential->CredentialBlob = NULL;
 287         credential->Persist = CRED_PERSIST_LOCAL_MACHINE;
 288         credential->AttributeCount = 0;
 289         credential->Attributes = NULL;
 290         credential->TargetAlias = NULL;
 291         credential->UserName = NULL;
 292     }
 293     for (i = 0; i < attr_list->count; i++)
 294     {
 295         switch (attr_list->attr[i].tag)
 296         {
 297             case kSecServiceItemAttr:
 298                 TRACE("kSecServiceItemAttr: %.*s\n", (int)attr_list->attr[i].length,
 299                       (char *)attr_list->attr[i].data);
 300                 if (!attr_list->attr[i].data) continue;
 301                 if (buffer)
 302                 {
 303                     INT str_len;
 304                     credential->TargetName = (LPWSTR)buffer;
 305                     str_len = MultiByteToWideChar(CP_UTF8, 0, attr_list->attr[i].data,
 306                                                   attr_list->attr[i].length, (LPWSTR)buffer, 0xffff);
 307                     credential->TargetName[str_len] = '\0';
 308                     buffer += (str_len + 1) * sizeof(WCHAR);
 309                     *len += (str_len + 1) * sizeof(WCHAR);
 310                 }
 311                 else
 312                 {
 313                     INT str_len;
 314                     str_len = MultiByteToWideChar(CP_UTF8, 0, attr_list->attr[i].data,
 315                                                   attr_list->attr[i].length, NULL, 0);
 316                     *len += (str_len + 1) * sizeof(WCHAR);
 317                 }
 318                 break;
 319             case kSecAccountItemAttr:
 320             {
 321                 INT str_len;
 322                 TRACE("kSecAccountItemAttr: %.*s\n", (int)attr_list->attr[i].length,
 323                       (char *)attr_list->attr[i].data);
 324                 if (!attr_list->attr[i].data) continue;
 325                 str_len = MultiByteToWideChar(CP_UTF8, 0, attr_list->attr[i].data,
 326                                               attr_list->attr[i].length, NULL, 0);
 327                 user = HeapAlloc(GetProcessHeap(), 0, (str_len + 1) * sizeof(WCHAR));
 328                 MultiByteToWideChar(CP_UTF8, 0, attr_list->attr[i].data,
 329                                     attr_list->attr[i].length, user, str_len);
 330                 user[str_len] = '\0';
 331                 break;
 332             }
 333             case kSecCommentItemAttr:
 334                 TRACE("kSecCommentItemAttr: %.*s\n", (int)attr_list->attr[i].length,
 335                       (char *)attr_list->attr[i].data);
 336                 if (!attr_list->attr[i].data) continue;
 337                 if (buffer)
 338                 {
 339                     INT str_len;
 340                     credential->Comment = (LPWSTR)buffer;
 341                     str_len = MultiByteToWideChar(CP_UTF8, 0, attr_list->attr[i].data,
 342                                                   attr_list->attr[i].length, (LPWSTR)buffer, 0xffff);
 343                     credential->Comment[str_len] = '\0';
 344                     buffer += (str_len + 1) * sizeof(WCHAR);
 345                     *len += (str_len + 1) * sizeof(WCHAR);
 346                 }
 347                 else
 348                 {
 349                     INT str_len;
 350                     str_len = MultiByteToWideChar(CP_UTF8, 0, attr_list->attr[i].data,
 351                                                   attr_list->attr[i].length, NULL, 0);
 352                     *len += (str_len + 1) * sizeof(WCHAR);
 353                 }
 354                 break;
 355             case kSecCreationDateItemAttr:
 356                 TRACE("kSecCreationDateItemAttr: %.*s\n", (int)attr_list->attr[i].length,
 357                       (char *)attr_list->attr[i].data);
 358                 if (buffer)
 359                 {
 360                     LARGE_INTEGER win_time;
 361                     struct tm tm;
 362                     time_t time;
 363                     memset(&tm, 0, sizeof(tm));
 364                     strptime(attr_list->attr[i].data, "%Y%m%d%H%M%SZ", &tm);
 365                     time = mktime(&tm);
 366                     RtlSecondsSince1970ToTime(time, &win_time);
 367                     credential->LastWritten.dwLowDateTime = win_time.u.LowPart;
 368                     credential->LastWritten.dwHighDateTime = win_time.u.HighPart;
 369                 }
 370                 break;
 371             default:
 372                 FIXME("unhandled attribute %lu\n", attr_list->attr[i].tag);
 373                 break;
 374         }
 375     }
 376
 377     if (user)
 378     {
 379         INT str_len;
 380         if (buffer)
 381             credential->UserName = (LPWSTR)buffer;
 382         str_len = strlenW(user);
 383         *len += (str_len + 1) * sizeof(WCHAR);
 384         if (buffer)
 385         {
 386             memcpy(buffer, user, (str_len + 1) * sizeof(WCHAR));
 387             buffer += (str_len + 1) * sizeof(WCHAR);
 388             TRACE("UserName = %s\n", debugstr_w(credential->UserName));
 389         }
 390     }
 391     HeapFree(GetProcessHeap(), 0, user);
 392
 393     if (cred_blob)
 394     {
 395         if (buffer)
 396         {
 397             INT str_len;
 398             credential->CredentialBlob = (BYTE *)buffer;
 399             str_len = MultiByteToWideChar(CP_UTF8, 0, cred_blob, cred_blob_len,
 400                                           (LPWSTR)buffer, 0xffff);
 401             credential->CredentialBlobSize = str_len * sizeof(WCHAR);
 402             *len += str_len * sizeof(WCHAR);
 403         }
 404         else
 405         {
 406             INT str_len;
 407             str_len = MultiByteToWideChar(CP_UTF8, 0, cred_blob, cred_blob_len,
 408                                           NULL, 0);
 409             *len += str_len * sizeof(WCHAR);
 410         }
 411     }
 412     SecKeychainItemFreeAttributesAndData(attr_list, cred_blob);
 413     return ERROR_SUCCESS;
 414 }
 415 #endif
 416
 417 static DWORD write_credential_blob(HKEY hkey, LPCWSTR target_name, DWORD type,
 418                                    const BYTE key_data[KEY_SIZE],
 419                                    const BYTE *credential_blob, DWORD credential_blob_size)
 420 {
 421     LPBYTE encrypted_credential_blob;
 422     struct ustring data;
 423     struct ustring key;
 424     DWORD ret;
 425
 426     key.Length = key.MaximumLength = KEY_SIZE;
 427     key.Buffer = (unsigned char *)key_data;
 428
 429     encrypted_credential_blob = HeapAlloc(GetProcessHeap(), 0, credential_blob_size);
 430     if (!encrypted_credential_blob) return ERROR_OUTOFMEMORY;
 431
 432     memcpy(encrypted_credential_blob, credential_blob, credential_blob_size);
 433     data.Length = data.MaximumLength = credential_blob_size;
 434     data.Buffer = encrypted_credential_blob;
 435     SystemFunction032(&data, &key);
 436
 437     ret = RegSetValueExW(hkey, wszPasswordValue, 0, REG_BINARY, encrypted_credential_blob, credential_blob_size);
 438     HeapFree(GetProcessHeap(), 0, encrypted_credential_blob);
 439
 440     return ret;
 441 }
 442
 443 static DWORD registry_write_credential(HKEY hkey, const CREDENTIALW *credential,
 444                                        const BYTE key_data[KEY_SIZE], BOOL preserve_blob)
 445 {
 446     DWORD ret;
 447     FILETIME LastWritten;
 448
 449     GetSystemTimeAsFileTime(&LastWritten);
 450
 451     ret = RegSetValueExW(hkey, wszFlagsValue, 0, REG_DWORD, (const BYTE*)&credential->Flags,
 452                          sizeof(credential->Flags));
 453     if (ret != ERROR_SUCCESS) return ret;
 454     ret = RegSetValueExW(hkey, wszTypeValue, 0, REG_DWORD, (const BYTE*)&credential->Type,
 455                          sizeof(credential->Type));
 456     if (ret != ERROR_SUCCESS) return ret;
 457     ret = RegSetValueExW(hkey, NULL, 0, REG_SZ, (LPVOID)credential->TargetName,
 458                          sizeof(WCHAR)*(strlenW(credential->TargetName)+1));
 459     if (ret != ERROR_SUCCESS) return ret;
 460     if (credential->Comment)
 461     {
 462         ret = RegSetValueExW(hkey, wszCommentValue, 0, REG_SZ, (LPVOID)credential->Comment,
 463                              sizeof(WCHAR)*(strlenW(credential->Comment)+1));
 464         if (ret != ERROR_SUCCESS) return ret;
 465     }
 466     ret = RegSetValueExW(hkey, wszLastWrittenValue, 0, REG_BINARY, (LPVOID)&LastWritten,
 467                          sizeof(LastWritten));
 468     if (ret != ERROR_SUCCESS) return ret;
 469     ret = RegSetValueExW(hkey, wszPersistValue, 0, REG_DWORD, (const BYTE*)&credential->Persist,
 470                          sizeof(credential->Persist));
 471     if (ret != ERROR_SUCCESS) return ret;
 472     /* FIXME: Attributes */
 473     if (credential->TargetAlias)
 474     {
 475         ret = RegSetValueExW(hkey, wszTargetAliasValue, 0, REG_SZ, (LPVOID)credential->TargetAlias,
 476                              sizeof(WCHAR)*(strlenW(credential->TargetAlias)+1));
 477         if (ret != ERROR_SUCCESS) return ret;
 478     }
 479     if (credential->UserName)
 480     {
 481         ret = RegSetValueExW(hkey, wszUserNameValue, 0, REG_SZ, (LPVOID)credential->UserName,
 482                              sizeof(WCHAR)*(strlenW(credential->UserName)+1));
 483         if (ret != ERROR_SUCCESS) return ret;
 484     }
 485     if (!preserve_blob)
 486     {
 487         ret = write_credential_blob(hkey, credential->TargetName, credential->Type,
 488                                     key_data, credential->CredentialBlob,
 489                                     credential->CredentialBlobSize);
 490     }
 491     return ret;
 492 }
 493
 494 #ifdef __APPLE__
 495 static DWORD mac_write_credential(const CREDENTIALW *credential, BOOL preserve_blob)
 496 {
 497     OSStatus status;
 498     SecKeychainItemRef keychain_item;
 499     char *username, *password, *servername;
 500     UInt32 userlen, pwlen, serverlen;
 501     SecKeychainAttribute attrs[1];
 502     SecKeychainAttributeList attr_list;
 503
 504     if (credential->Flags)
 505         FIXME("Flags 0x%x not written\n", credential->Flags);
 506     if (credential->Type != CRED_TYPE_DOMAIN_PASSWORD)
 507         FIXME("credential type of %d not supported\n", credential->Type);
 508     if (credential->Persist != CRED_PERSIST_LOCAL_MACHINE)
 509         FIXME("persist value of %d not supported\n", credential->Persist);
 510     if (credential->AttributeCount)
 511         FIXME("custom attributes not supported\n");
 512
 513     userlen = WideCharToMultiByte(CP_UTF8, 0, credential->UserName, -1, NULL, 0, NULL, NULL);
 514     username = HeapAlloc(GetProcessHeap(), 0, userlen * sizeof(*username));
 515     WideCharToMultiByte(CP_UTF8, 0, credential->UserName, -1, username, userlen, NULL, NULL);
 516
 517     serverlen = WideCharToMultiByte(CP_UTF8, 0, credential->TargetName, -1, NULL, 0, NULL, NULL);
 518     servername = HeapAlloc(GetProcessHeap(), 0, serverlen * sizeof(*servername));
 519     WideCharToMultiByte(CP_UTF8, 0, credential->TargetName, -1, servername, serverlen, NULL, NULL);
 520     pwlen = WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR)credential->CredentialBlob,
 521                                 credential->CredentialBlobSize / sizeof(WCHAR), NULL, 0, NULL, NULL);
 522     password = HeapAlloc(GetProcessHeap(), 0, pwlen * sizeof(*password));
 523     WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR)credential->CredentialBlob,
 524                         credential->CredentialBlobSize / sizeof(WCHAR), password, pwlen, NULL, NULL);
 525
 526     TRACE("adding server %s, username %s using Keychain\n", servername, username);
 527     status = SecKeychainAddGenericPassword(NULL, strlen(servername), servername, strlen(username),
 528                                            username, strlen(password), password, &keychain_item);
 529     if (status != noErr)
 530         ERR("SecKeychainAddGenericPassword returned %ld\n", status);
 531     if (status == errSecDuplicateItem)
 532     {
 533         status = SecKeychainFindGenericPassword(NULL, strlen(servername), servername, strlen(username),
 534                                                 username, NULL, NULL, &keychain_item);
 535         if (status != noErr)
 536             ERR("SecKeychainFindGenericPassword returned %ld\n", status);
 537     }
 538     HeapFree(GetProcessHeap(), 0, username);
 539     HeapFree(GetProcessHeap(), 0, servername);
 540     if (status != noErr)
 541     {
 542         HeapFree(GetProcessHeap(), 0, password);
 543         return ERROR_GEN_FAILURE;
 544     }
 545     if (credential->Comment)
 546     {
 547         attr_list.count = 1;
 548         attr_list.attr = attrs;
 549         attrs[0].tag = kSecCommentItemAttr;
 550         attrs[0].length = WideCharToMultiByte(CP_UTF8, 0, credential->Comment, -1, NULL, 0, NULL, NULL);
 551         if (attrs[0].length) attrs[0].length--;
 552         attrs[0].data = HeapAlloc(GetProcessHeap(), 0, attrs[0].length);
 553         WideCharToMultiByte(CP_UTF8, 0, credential->Comment, -1, attrs[0].data, attrs[0].length, NULL, NULL);
 554     }
 555     else
 556     {
 557         attr_list.count = 0;
 558         attr_list.attr = NULL;
 559     }
 560     status = SecKeychainItemModifyAttributesAndData(keychain_item, &attr_list,
 561                                                     preserve_blob ? 0 : strlen(password),
 562                                                     preserve_blob ? NULL : password);
 563     if (credential->Comment)
 564         HeapFree(GetProcessHeap(), 0, attrs[0].data);
 565     HeapFree(GetProcessHeap(), 0, password);
 566     /* FIXME: set TargetAlias attribute */
 567     CFRelease(keychain_item);
 568     if (status != noErr)
 569         return ERROR_GEN_FAILURE;
 570     return ERROR_SUCCESS;
 571 }
 572 #endif
 573
 574 static DWORD open_cred_mgr_key(HKEY *hkey, BOOL open_for_write)
 575 {
 576     return RegCreateKeyExW(HKEY_CURRENT_USER, wszCredentialManagerKey, 0,
 577                            NULL, REG_OPTION_NON_VOLATILE,
 578                            KEY_READ | (open_for_write ? KEY_WRITE : 0), NULL, hkey, NULL);
 579 }
 580
 581 static DWORD get_cred_mgr_encryption_key(HKEY hkeyMgr, BYTE key_data[KEY_SIZE])
 582 {
 583     static const BYTE my_key_data[KEY_SIZE] = { 0 };
 584     DWORD type;
 585     DWORD count;
 586     FILETIME ft;
 587     ULONG seed;
 588     ULONG value;
 589     DWORD ret;
 590
 591     memcpy(key_data, my_key_data, KEY_SIZE);
 592
 593     count = KEY_SIZE;
 594     ret = RegQueryValueExW(hkeyMgr, wszEncryptionKeyValue, NULL, &type, key_data,
 595                            &count);
 596     if (ret == ERROR_SUCCESS)
 597     {
 598         if (type != REG_BINARY)
 599             return ERROR_REGISTRY_CORRUPT;
 600         else
 601             return ERROR_SUCCESS;
 602     }
 603     if (ret != ERROR_FILE_NOT_FOUND)
 604         return ret;
 605
 606     GetSystemTimeAsFileTime(&ft);
 607     seed = ft.dwLowDateTime;
 608     value = RtlUniform(&seed);
 609     *(DWORD *)key_data = value;
 610     seed = ft.dwHighDateTime;
 611     value = RtlUniform(&seed);
 612     *(DWORD *)(key_data + 4) = value;
 613
 614     ret = RegSetValueExW(hkeyMgr, wszEncryptionKeyValue, 0, REG_BINARY,
 615                          key_data, KEY_SIZE);
 616     if (ret == ERROR_ACCESS_DENIED)
 617     {
 618         ret = open_cred_mgr_key(&hkeyMgr, TRUE);
 619         if (ret == ERROR_SUCCESS)
 620         {
 621             ret = RegSetValueExW(hkeyMgr, wszEncryptionKeyValue, 0, REG_BINARY,
 622                                  key_data, KEY_SIZE);
 623             RegCloseKey(hkeyMgr);
 624         }
 625     }
 626     return ret;
 627 }
 628
 629 static LPWSTR get_key_name_for_target(LPCWSTR target_name, DWORD type)
 630 {
 631     static const WCHAR wszGenericPrefix[] = {'G','e','n','e','r','i','c',':',' ',0};
 632     static const WCHAR wszDomPasswdPrefix[] = {'D','o','m','P','a','s','s','w','d',':',' ',0};
 633     INT len;
 634     LPCWSTR prefix = NULL;
 635     LPWSTR key_name, p;
 636
 637     len = strlenW(target_name);
 638     if (type == CRED_TYPE_GENERIC)
 639     {
 640         prefix = wszGenericPrefix;
 641         len += sizeof(wszGenericPrefix)/sizeof(wszGenericPrefix[0]);
 642     }
 643     else
 644     {
 645         prefix = wszDomPasswdPrefix;
 646         len += sizeof(wszDomPasswdPrefix)/sizeof(wszDomPasswdPrefix[0]);
 647     }
 648
 649     key_name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 650     if (!key_name) return NULL;
 651
 652     strcpyW(key_name, prefix);
 653     strcatW(key_name, target_name);
 654
 655     for (p = key_name; *p; p++)
 656         if (*p == '\\') *p = '_';
 657
 658     return key_name;
 659 }
 660
 661 static BOOL registry_credential_matches_filter(HKEY hkeyCred, LPCWSTR filter)
 662 {
 663     LPWSTR target_name;
 664     DWORD ret;
 665     DWORD type;
 666     DWORD count;
 667     LPCWSTR p;
 668
 669     if (!filter) return TRUE;
 670
 671     ret = RegQueryValueExW(hkeyCred, NULL, 0, &type, NULL, &count);
 672     if (ret != ERROR_SUCCESS)
 673         return FALSE;
 674     else if (type != REG_SZ)
 675         return FALSE;
 676
 677     target_name = HeapAlloc(GetProcessHeap(), 0, count);
 678     if (!target_name)
 679         return FALSE;
 680     ret = RegQueryValueExW(hkeyCred, NULL, 0, &type, (LPVOID)target_name, &count);
 681     if (ret != ERROR_SUCCESS || type != REG_SZ)
 682     {
 683         HeapFree(GetProcessHeap(), 0, target_name);
 684         return FALSE;
 685     }
 686
 687     TRACE("comparing filter %s to target name %s\n", debugstr_w(filter),
 688           debugstr_w(target_name));
 689
 690     p = strchrW(filter, '*');
 691     ret = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, filter,
 692                          (p && !p[1] ? p - filter : -1), target_name,
 693                          (p && !p[1] ? p - filter : -1)) == CSTR_EQUAL;
 694
 695     HeapFree(GetProcessHeap(), 0, target_name);
 696     return ret;
 697 }
 698
 699 static DWORD registry_enumerate_credentials(HKEY hkeyMgr, LPCWSTR filter,
 700                                             LPWSTR target_name,
 701                                             DWORD target_name_len, const BYTE key_data[KEY_SIZE],
 702                                             PCREDENTIALW *credentials, char **buffer,
 703                                             DWORD *len, DWORD *count)
 704 {
 705     DWORD i;
 706     DWORD ret;
 707     for (i = 0;; i++)
 708     {
 709         HKEY hkeyCred;
 710         ret = RegEnumKeyW(hkeyMgr, i, target_name, target_name_len+1);
 711         if (ret == ERROR_NO_MORE_ITEMS)
 712         {
 713             ret = ERROR_SUCCESS;
 714             break;
 715         }
 716         else if (ret != ERROR_SUCCESS)
 717             continue;
 718         TRACE("target_name = %s\n", debugstr_w(target_name));
 719         ret = RegOpenKeyExW(hkeyMgr, target_name, 0, KEY_QUERY_VALUE, &hkeyCred);
 720         if (ret != ERROR_SUCCESS)
 721             continue;
 722         if (!registry_credential_matches_filter(hkeyCred, filter))
 723         {
 724             RegCloseKey(hkeyCred);
 725             continue;
 726         }
 727         if (buffer)
 728         {
 729             *len = sizeof(CREDENTIALW);
 730             credentials[*count] = (PCREDENTIALW)*buffer;
 731         }
 732         else
 733             *len += sizeof(CREDENTIALW);
 734         ret = registry_read_credential(hkeyCred, buffer ? credentials[*count] : NULL,
 735                                        key_data, buffer ? *buffer + sizeof(CREDENTIALW) : NULL,
 736                                        len);
 737         RegCloseKey(hkeyCred);
 738         if (ret != ERROR_SUCCESS) break;
 739         if (buffer) *buffer += *len;
 740         (*count)++;
 741     }
 742     return ret;
 743 }
 744
 745 #ifdef __APPLE__
 746 static BOOL mac_credential_matches_filter(void *data, UInt32 data_len, const WCHAR *filter)
 747 {
 748     int len;
 749     WCHAR *target_name;
 750     const WCHAR *p;
 751     BOOL ret;
 752
 753     if (!filter) return TRUE;
 754
 755     len = MultiByteToWideChar(CP_UTF8, 0, data, data_len, NULL, 0);
 756     if (!(target_name = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR)))) return FALSE;
 757     MultiByteToWideChar(CP_UTF8, 0, data, data_len, target_name, len);
 758     target_name[len] = 0;
 759
 760     TRACE("comparing filter %s to target name %s\n", debugstr_w(filter), debugstr_w(target_name));
 761
 762     p = strchrW(filter, '*');
 763     ret = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, filter,
 764                          (p && !p[1] ? p - filter : -1), target_name,
 765                          (p && !p[1] ? p - filter : -1)) == CSTR_EQUAL;
 766     HeapFree(GetProcessHeap(), 0, target_name);
 767     return ret;
 768 }
 769
 770 static DWORD mac_enumerate_credentials(LPCWSTR filter, PCREDENTIALW *credentials,
 771                                        char *buffer, DWORD *len, DWORD *count)
 772 {
 773     SecKeychainSearchRef search;
 774     SecKeychainItemRef item;
 775     OSStatus status;
 776     Boolean saved_user_interaction_allowed;
 777     DWORD ret;
 778
 779     SecKeychainGetUserInteractionAllowed(&saved_user_interaction_allowed);
 780     SecKeychainSetUserInteractionAllowed(false);
 781
 782     status = SecKeychainSearchCreateFromAttributes(NULL, kSecGenericPasswordItemClass, NULL, &search);
 783     if (status == noErr)
 784     {
 785         while (SecKeychainSearchCopyNext(search, &item) == noErr)
 786         {
 787             SecKeychainAttributeInfo info;
 788             SecKeychainAttributeList *attr_list;
 789             UInt32 info_tags[] = { kSecServiceItemAttr };
 790             BOOL match;
 791
 792             info.count = sizeof(info_tags)/sizeof(info_tags[0]);
 793             info.tag = info_tags;
 794             info.format = NULL;
 795             status = SecKeychainItemCopyAttributesAndData(item, &info, NULL, &attr_list, NULL, NULL);
 796             if (status != noErr)
 797             {
 798                 WARN("SecKeychainItemCopyAttributesAndData returned status %ld\n", status);
 799                 continue;
 800             }
 801             if (buffer)
 802             {
 803                 *len = sizeof(CREDENTIALW);
 804                 credentials[*count] = (PCREDENTIALW)buffer;
 805             }
 806             else
 807                 *len += sizeof(CREDENTIALW);
 808             if (attr_list->count != 1 || attr_list->attr[0].tag != kSecServiceItemAttr)
 809             {
 810                 SecKeychainItemFreeAttributesAndData(attr_list, NULL);
 811                 continue;
 812             }
 813             TRACE("service item: %.*s\n", (int)attr_list->attr[0].length, (char *)attr_list->attr[0].data);
 814             match = mac_credential_matches_filter(attr_list->attr[0].data, attr_list->attr[0].length, filter);
 815             SecKeychainItemFreeAttributesAndData(attr_list, NULL);
 816             if (!match) continue;
 817             ret = mac_read_credential_from_item(item, FALSE,
 818                                                 buffer ? credentials[*count] : NULL,
 819                                                 buffer ? buffer + sizeof(CREDENTIALW) : NULL,
 820                                                 len);
 821             CFRelease(item);
 822             if (ret == ERROR_SUCCESS)
 823             {
 824                 (*count)++;
 825                 if (buffer) buffer += *len;
 826             }
 827         }
 828         CFRelease(search);
 829     }
 830     else
 831         ERR("SecKeychainSearchCreateFromAttributes returned status %ld\n", status);
 832     SecKeychainSetUserInteractionAllowed(saved_user_interaction_allowed);
 833     return ERROR_SUCCESS;
 834 }
 835
 836 static DWORD mac_delete_credential(LPCWSTR TargetName)
 837 {
 838     OSStatus status;
 839     SecKeychainSearchRef search;
 840     status = SecKeychainSearchCreateFromAttributes(NULL, kSecGenericPasswordItemClass, NULL, &search);
 841     if (status == noErr)
 842     {
 843         SecKeychainItemRef item;
 844         while (SecKeychainSearchCopyNext(search, &item) == noErr)
 845         {
 846             SecKeychainAttributeInfo info;
 847             SecKeychainAttributeList *attr_list;
 848             UInt32 info_tags[] = { kSecServiceItemAttr };
 849             LPWSTR target_name;
 850             INT str_len;
 851             info.count = sizeof(info_tags)/sizeof(info_tags[0]);
 852             info.tag = info_tags;
 853             info.format = NULL;
 854             status = SecKeychainItemCopyAttributesAndData(item, &info, NULL, &attr_list, NULL, NULL);
 855             if (status != noErr)
 856             {
 857                 WARN("SecKeychainItemCopyAttributesAndData returned status %ld\n", status);
 858                 continue;
 859             }
 860             if (attr_list->count != 1 || attr_list->attr[0].tag != kSecServiceItemAttr)
 861             {
 862                 CFRelease(item);
 863                 continue;
 864             }
 865             str_len = MultiByteToWideChar(CP_UTF8, 0, attr_list->attr[0].data, attr_list->attr[0].length, NULL, 0);
 866             target_name = HeapAlloc(GetProcessHeap(), 0, (str_len + 1) * sizeof(WCHAR));
 867             MultiByteToWideChar(CP_UTF8, 0, attr_list->attr[0].data, attr_list->attr[0].length, target_name, str_len);
 868             /* nul terminate */
 869             target_name[str_len] = '\0';
 870             if (strcmpiW(TargetName, target_name))
 871             {
 872                 CFRelease(item);
 873                 HeapFree(GetProcessHeap(), 0, target_name);
 874                 continue;
 875             }
 876             HeapFree(GetProcessHeap(), 0, target_name);
 877             SecKeychainItemFreeAttributesAndData(attr_list, NULL);
 878             SecKeychainItemDelete(item);
 879             CFRelease(item);
 880             CFRelease(search);
 881
 882             return ERROR_SUCCESS;
 883         }
 884         CFRelease(search);
 885     }
 886     return ERROR_NOT_FOUND;
 887 }
 888 #endif
 889
 890 /******************************************************************************
 891  * convert_PCREDENTIALW_to_PCREDENTIALA [internal]
 892  *
 893  * convert a Credential struct from UNICODE to ANSI and return the needed size in Bytes
 894  *
 895  */
 896
 897 static INT convert_PCREDENTIALW_to_PCREDENTIALA(const CREDENTIALW *CredentialW, PCREDENTIALA CredentialA, DWORD len)
 898 {
 899     char *buffer;
 900     INT string_len;
 901     INT needed = sizeof(CREDENTIALA);
 902
 903     if (!CredentialA)
 904     {
 905         if (CredentialW->TargetName)
 906             needed += WideCharToMultiByte(CP_ACP, 0, CredentialW->TargetName, -1, NULL, 0, NULL, NULL);
 907         if (CredentialW->Comment)
 908             needed += WideCharToMultiByte(CP_ACP, 0, CredentialW->Comment, -1, NULL, 0, NULL, NULL);
 909         needed += CredentialW->CredentialBlobSize;
 910         if (CredentialW->TargetAlias)
 911             needed += WideCharToMultiByte(CP_ACP, 0, CredentialW->TargetAlias, -1, NULL, 0, NULL, NULL);
 912         if (CredentialW->UserName)
 913             needed += WideCharToMultiByte(CP_ACP, 0, CredentialW->UserName, -1, NULL, 0, NULL, NULL);
 914
 915         return needed;
 916     }
 917
 918
 919     buffer = (char *)CredentialA + sizeof(CREDENTIALA);
 920     len -= sizeof(CREDENTIALA);
 921     CredentialA->Flags = CredentialW->Flags;
 922     CredentialA->Type = CredentialW->Type;
 923
 924     if (CredentialW->TargetName)
 925     {
 926         CredentialA->TargetName = buffer;
 927         string_len = WideCharToMultiByte(CP_ACP, 0, CredentialW->TargetName, -1, buffer, len, NULL, NULL);
 928         buffer += string_len;
 929         needed += string_len;
 930         len -= string_len;
 931     }
 932     else
 933         CredentialA->TargetName = NULL;
 934     if (CredentialW->Comment)
 935     {
 936         CredentialA->Comment = buffer;
 937         string_len = WideCharToMultiByte(CP_ACP, 0, CredentialW->Comment, -1, buffer, len, NULL, NULL);
 938         buffer += string_len;
 939         needed += string_len;
 940         len -= string_len;
 941     }
 942     else
 943         CredentialA->Comment = NULL;
 944     CredentialA->LastWritten = CredentialW->LastWritten;
 945     CredentialA->CredentialBlobSize = CredentialW->CredentialBlobSize;
 946     if (CredentialW->CredentialBlobSize && (CredentialW->CredentialBlobSize <= len))
 947     {
 948         CredentialA->CredentialBlob =(LPBYTE)buffer;
 949         memcpy(CredentialA->CredentialBlob, CredentialW->CredentialBlob,
 950                CredentialW->CredentialBlobSize);
 951         buffer += CredentialW->CredentialBlobSize;
 952         needed += CredentialW->CredentialBlobSize;
 953         len -= CredentialW->CredentialBlobSize;
 954     }
 955     else
 956         CredentialA->CredentialBlob = NULL;
 957     CredentialA->Persist = CredentialW->Persist;
 958     CredentialA->AttributeCount = 0;
 959     CredentialA->Attributes = NULL; /* FIXME */
 960     if (CredentialW->TargetAlias)
 961     {
 962         CredentialA->TargetAlias = buffer;
 963         string_len = WideCharToMultiByte(CP_ACP, 0, CredentialW->TargetAlias, -1, buffer, len, NULL, NULL);
 964         buffer += string_len;
 965         needed += string_len;
 966         len -= string_len;
 967     }
 968     else
 969         CredentialA->TargetAlias = NULL;
 970     if (CredentialW->UserName)
 971     {
 972         CredentialA->UserName = buffer;
 973         string_len = WideCharToMultiByte(CP_ACP, 0, CredentialW->UserName, -1, buffer, len, NULL, NULL);
 974         needed += string_len;
 975     }
 976     else
 977         CredentialA->UserName = NULL;
 978
 979     return needed;
 980 }
 981
 982 /******************************************************************************
 983  * convert_PCREDENTIALA_to_PCREDENTIALW [internal]
 984  *
 985  * convert a Credential struct from ANSI to UNICODE and return the needed size in Bytes
 986  *
 987  */
 988 static INT convert_PCREDENTIALA_to_PCREDENTIALW(const CREDENTIALA *CredentialA, PCREDENTIALW CredentialW, INT len)
 989 {
 990     char *buffer;
 991     INT string_len;
 992     INT needed = sizeof(CREDENTIALW);
 993
 994     if (!CredentialW)
 995     {
 996         if (CredentialA->TargetName)
 997             needed += sizeof(WCHAR) * MultiByteToWideChar(CP_ACP, 0, CredentialA->TargetName, -1, NULL, 0);
 998         if (CredentialA->Comment)
 999             needed += sizeof(WCHAR) * MultiByteToWideChar(CP_ACP, 0, CredentialA->Comment, -1, NULL, 0);
1000         needed += CredentialA->CredentialBlobSize;
1001         if (CredentialA->TargetAlias)
1002             needed += sizeof(WCHAR) * MultiByteToWideChar(CP_ACP, 0, CredentialA->TargetAlias, -1, NULL, 0);
1003         if (CredentialA->UserName)
1004             needed += sizeof(WCHAR) * MultiByteToWideChar(CP_ACP, 0, CredentialA->UserName, -1, NULL, 0);
1005
1006         return needed;
1007     }
1008
1009     buffer = (char *)CredentialW + sizeof(CREDENTIALW);
1010     len -= sizeof(CREDENTIALW);
1011     CredentialW->Flags = CredentialA->Flags;
1012     CredentialW->Type = CredentialA->Type;
1013     if (CredentialA->TargetName)
1014     {
1015         CredentialW->TargetName = (LPWSTR)buffer;
1016         string_len = MultiByteToWideChar(CP_ACP, 0, CredentialA->TargetName, -1, CredentialW->TargetName, len / sizeof(WCHAR));
1017         buffer += sizeof(WCHAR) * string_len;
1018         needed += sizeof(WCHAR) * string_len;
1019         len -= sizeof(WCHAR) * string_len;
1020     }
1021     else
1022         CredentialW->TargetName = NULL;
1023     if (CredentialA->Comment)
1024     {
1025         CredentialW->Comment = (LPWSTR)buffer;
1026         string_len = MultiByteToWideChar(CP_ACP, 0, CredentialA->Comment, -1, CredentialW->Comment, len / sizeof(WCHAR));
1027         buffer += sizeof(WCHAR) * string_len;
1028         needed += sizeof(WCHAR) * string_len;
1029         len -= sizeof(WCHAR) * string_len;
1030     }
1031     else
1032         CredentialW->Comment = NULL;
1033     CredentialW->LastWritten = CredentialA->LastWritten;
1034     CredentialW->CredentialBlobSize = CredentialA->CredentialBlobSize;
1035     if (CredentialA->CredentialBlobSize)
1036     {
1037         CredentialW->CredentialBlob =(LPBYTE)buffer;
1038         memcpy(CredentialW->CredentialBlob, CredentialA->CredentialBlob,
1039                CredentialA->CredentialBlobSize);
1040         buffer += CredentialA->CredentialBlobSize;
1041         needed += CredentialA->CredentialBlobSize;
1042         len -= CredentialA->CredentialBlobSize;
1043     }
1044     else
1045         CredentialW->CredentialBlob = NULL;
1046     CredentialW->Persist = CredentialA->Persist;
1047     CredentialW->AttributeCount = 0;
1048     CredentialW->Attributes = NULL; /* FIXME */
1049     if (CredentialA->TargetAlias)
1050     {
1051         CredentialW->TargetAlias = (LPWSTR)buffer;
1052         string_len = MultiByteToWideChar(CP_ACP, 0, CredentialA->TargetAlias, -1, CredentialW->TargetAlias, len / sizeof(WCHAR));
1053         buffer += sizeof(WCHAR) * string_len;
1054         needed += sizeof(WCHAR) * string_len;
1055         len -= sizeof(WCHAR) * string_len;
1056     }
1057     else
1058         CredentialW->TargetAlias = NULL;
1059     if (CredentialA->UserName)
1060     {
1061         CredentialW->UserName = (LPWSTR)buffer;
1062         string_len = MultiByteToWideChar(CP_ACP, 0, CredentialA->UserName, -1, CredentialW->UserName, len / sizeof(WCHAR));
1063         needed += sizeof(WCHAR) * string_len;
1064     }
1065     else
1066         CredentialW->UserName = NULL;
1067
1068     return needed;
1069 }
1070
1071 /******************************************************************************
1072  * CredDeleteA [ADVAPI32.@]
1073  */
1074 BOOL WINAPI CredDeleteA(LPCSTR TargetName, DWORD Type, DWORD Flags)
1075 {
1076     LPWSTR TargetNameW;
1077     DWORD len;
1078     BOOL ret;
1079
1080     TRACE("(%s, %d, 0x%x)\n", debugstr_a(TargetName), Type, Flags);
1081
1082     if (!TargetName)
1083     {
1084         SetLastError(ERROR_INVALID_PARAMETER);
1085         return FALSE;
1086     }
1087
1088     len = MultiByteToWideChar(CP_ACP, 0, TargetName, -1, NULL, 0);
1089     TargetNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1090     if (!TargetNameW)
1091     {
1092         SetLastError(ERROR_OUTOFMEMORY);
1093         return FALSE;
1094     }
1095     MultiByteToWideChar(CP_ACP, 0, TargetName, -1, TargetNameW, len);
1096
1097     ret = CredDeleteW(TargetNameW, Type, Flags);
1098
1099     HeapFree(GetProcessHeap(), 0, TargetNameW);
1100
1101     return ret;
1102 }
1103
1104 /******************************************************************************
1105  * CredDeleteW [ADVAPI32.@]
1106  */
1107 BOOL WINAPI CredDeleteW(LPCWSTR TargetName, DWORD Type, DWORD Flags)
1108 {
1109     HKEY hkeyMgr;
1110     DWORD ret;
1111     LPWSTR key_name;
1112
1113     TRACE("(%s, %d, 0x%x)\n", debugstr_w(TargetName), Type, Flags);
1114
1115     if (!TargetName)
1116     {
1117         SetLastError(ERROR_INVALID_PARAMETER);
1118         return FALSE;
1119     }
1120
1121     if (Type != CRED_TYPE_GENERIC && Type != CRED_TYPE_DOMAIN_PASSWORD)
1122     {
1123         FIXME("unhandled type %d\n", Type);
1124         SetLastError(ERROR_INVALID_PARAMETER);
1125         return FALSE;
1126     }
1127
1128     if (Flags)
1129     {
1130         FIXME("unhandled flags 0x%x\n", Flags);
1131         SetLastError(ERROR_INVALID_FLAGS);
1132         return FALSE;
1133     }
1134
1135 #ifdef __APPLE__
1136     if (Type == CRED_TYPE_DOMAIN_PASSWORD)
1137     {
1138         ret = mac_delete_credential(TargetName);
1139         if (ret == ERROR_SUCCESS)
1140             return TRUE;
1141     }
1142 #endif
1143
1144     ret = open_cred_mgr_key(&hkeyMgr, TRUE);
1145     if (ret != ERROR_SUCCESS)
1146     {
1147         WARN("couldn't open/create manager key, error %d\n", ret);
1148         SetLastError(ERROR_NO_SUCH_LOGON_SESSION);
1149         return FALSE;
1150     }
1151
1152     key_name = get_key_name_for_target(TargetName, Type);
1153     ret = RegDeleteKeyW(hkeyMgr, key_name);
1154     HeapFree(GetProcessHeap(), 0, key_name);
1155     RegCloseKey(hkeyMgr);
1156     if (ret != ERROR_SUCCESS)
1157     {
1158         SetLastError(ERROR_NOT_FOUND);
1159         return FALSE;
1160     }
1161
1162     return TRUE;
1163 }
1164
1165 /******************************************************************************
1166  * CredEnumerateA [ADVAPI32.@]
1167  */
1168 BOOL WINAPI CredEnumerateA(LPCSTR Filter, DWORD Flags, DWORD *Count,
1169                            PCREDENTIALA **Credentials)
1170 {
1171     LPWSTR FilterW;
1172     PCREDENTIALW *CredentialsW;
1173     DWORD i;
1174     INT len;
1175     INT needed;
1176     char *buffer;
1177
1178     TRACE("(%s, 0x%x, %p, %p)\n", debugstr_a(Filter), Flags, Count, Credentials);
1179
1180     if (Filter)
1181     {
1182         len = MultiByteToWideChar(CP_ACP, 0, Filter, -1, NULL, 0);
1183         FilterW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1184         if (!FilterW)
1185         {
1186             SetLastError(ERROR_OUTOFMEMORY);
1187             return FALSE;
1188         }
1189         MultiByteToWideChar(CP_ACP, 0, Filter, -1, FilterW, len);
1190     }
1191     else
1192         FilterW = NULL;
1193
1194     if (!CredEnumerateW(FilterW, Flags, Count, &CredentialsW))
1195     {
1196         HeapFree(GetProcessHeap(), 0, FilterW);
1197         return FALSE;
1198     }
1199     HeapFree(GetProcessHeap(), 0, FilterW);
1200
1201     len = *Count * sizeof(PCREDENTIALA);
1202     for (i = 0; i < *Count; i++)
1203         len += convert_PCREDENTIALW_to_PCREDENTIALA(CredentialsW[i], NULL, 0);
1204
1205     *Credentials = HeapAlloc(GetProcessHeap(), 0, len);
1206     if (!*Credentials)
1207     {
1208         CredFree(CredentialsW);
1209         SetLastError(ERROR_OUTOFMEMORY);
1210         return FALSE;
1211     }
1212
1213     buffer = (char *)&(*Credentials)[*Count];
1214     len -= *Count * sizeof(PCREDENTIALA);
1215     for (i = 0; i < *Count; i++)
1216     {
1217         (*Credentials)[i] = (PCREDENTIALA)buffer;
1218         needed = convert_PCREDENTIALW_to_PCREDENTIALA(CredentialsW[i], (*Credentials)[i], len);
1219         buffer += needed;
1220         len -= needed;
1221     }
1222
1223     CredFree(CredentialsW);
1224
1225     return TRUE;
1226 }
1227
1228 /******************************************************************************
1229  * CredEnumerateW [ADVAPI32.@]
1230  */
1231 BOOL WINAPI CredEnumerateW(LPCWSTR Filter, DWORD Flags, DWORD *Count,
1232                            PCREDENTIALW **Credentials)
1233 {
1234     HKEY hkeyMgr;
1235     DWORD ret;
1236     LPWSTR target_name;
1237     DWORD target_name_len;
1238     DWORD len;
1239     char *buffer;
1240     BYTE key_data[KEY_SIZE];
1241
1242     TRACE("(%s, 0x%x, %p, %p)\n", debugstr_w(Filter), Flags, Count, Credentials);
1243
1244     if (Flags)
1245     {
1246         SetLastError(ERROR_INVALID_FLAGS);
1247         return FALSE;
1248     }
1249
1250     ret = open_cred_mgr_key(&hkeyMgr, FALSE);
1251     if (ret != ERROR_SUCCESS)
1252     {
1253         WARN("couldn't open/create manager key, error %d\n", ret);
1254         SetLastError(ERROR_NO_SUCH_LOGON_SESSION);
1255         return FALSE;
1256     }
1257
1258     ret = get_cred_mgr_encryption_key(hkeyMgr, key_data);
1259     if (ret != ERROR_SUCCESS)
1260     {
1261         RegCloseKey(hkeyMgr);
1262         SetLastError(ret);
1263         return FALSE;
1264     }
1265
1266     ret = RegQueryInfoKeyW(hkeyMgr, NULL, NULL, NULL, NULL, &target_name_len, NULL, NULL, NULL, NULL, NULL, NULL);
1267     if (ret != ERROR_SUCCESS)
1268     {
1269         RegCloseKey(hkeyMgr);
1270         SetLastError(ret);
1271         return FALSE;
1272     }
1273
1274     target_name = HeapAlloc(GetProcessHeap(), 0, (target_name_len+1)*sizeof(WCHAR));
1275     if (!target_name)
1276     {
1277         RegCloseKey(hkeyMgr);
1278         SetLastError(ERROR_OUTOFMEMORY);
1279         return FALSE;
1280     }
1281
1282     *Count = 0;
1283     len = 0;
1284     ret = registry_enumerate_credentials(hkeyMgr, Filter, target_name, target_name_len,
1285                                          key_data, NULL, NULL, &len, Count);
1286 #ifdef __APPLE__
1287     if (ret == ERROR_SUCCESS)
1288         ret = mac_enumerate_credentials(Filter, NULL, NULL, &len, Count);
1289 #endif
1290     if (ret == ERROR_SUCCESS && *Count == 0)
1291         ret = ERROR_NOT_FOUND;
1292     if (ret != ERROR_SUCCESS)
1293     {
1294         HeapFree(GetProcessHeap(), 0, target_name);
1295         RegCloseKey(hkeyMgr);
1296         SetLastError(ret);
1297         return FALSE;
1298     }
1299     len += *Count * sizeof(PCREDENTIALW);
1300
1301     if (ret == ERROR_SUCCESS)
1302     {
1303         buffer = HeapAlloc(GetProcessHeap(), 0, len);
1304         *Credentials = (PCREDENTIALW *)buffer;
1305         if (buffer)
1306         {
1307             buffer += *Count * sizeof(PCREDENTIALW);
1308             *Count = 0;
1309             ret = registry_enumerate_credentials(hkeyMgr, Filter, target_name,
1310                                                  target_name_len, key_data,
1311                                                  *Credentials, &buffer, &len,
1312                                                  Count);
1313 #ifdef __APPLE__
1314             if (ret == ERROR_SUCCESS)
1315                 ret = mac_enumerate_credentials(Filter, *Credentials,
1316                                                 buffer, &len, Count);
1317 #endif
1318         }
1319         else
1320             ret = ERROR_OUTOFMEMORY;
1321     }
1322
1323     HeapFree(GetProcessHeap(), 0, target_name);
1324     RegCloseKey(hkeyMgr);
1325
1326     if (ret != ERROR_SUCCESS)
1327     {
1328         SetLastError(ret);
1329         return FALSE;
1330     }
1331     return TRUE;
1332 }
1333
1334 /******************************************************************************
1335  * CredFree [ADVAPI32.@]
1336  */
1337 VOID WINAPI CredFree(PVOID Buffer)
1338 {
1339     HeapFree(GetProcessHeap(), 0, Buffer);
1340 }
1341
1342 /******************************************************************************
1343  * CredReadA [ADVAPI32.@]
1344  */
1345 BOOL WINAPI CredReadA(LPCSTR TargetName, DWORD Type, DWORD Flags, PCREDENTIALA *Credential)
1346 {
1347     LPWSTR TargetNameW;
1348     PCREDENTIALW CredentialW;
1349     INT len;
1350
1351     TRACE("(%s, %d, 0x%x, %p)\n", debugstr_a(TargetName), Type, Flags, Credential);
1352
1353     if (!TargetName)
1354     {
1355         SetLastError(ERROR_INVALID_PARAMETER);
1356         return FALSE;
1357     }
1358
1359     len = MultiByteToWideChar(CP_ACP, 0, TargetName, -1, NULL, 0);
1360     TargetNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1361     if (!TargetNameW)
1362     {
1363         SetLastError(ERROR_OUTOFMEMORY);
1364         return FALSE;
1365     }
1366     MultiByteToWideChar(CP_ACP, 0, TargetName, -1, TargetNameW, len);
1367
1368     if (!CredReadW(TargetNameW, Type, Flags, &CredentialW))
1369     {
1370         HeapFree(GetProcessHeap(), 0, TargetNameW);
1371         return FALSE;
1372     }
1373     HeapFree(GetProcessHeap(), 0, TargetNameW);
1374
1375     len = convert_PCREDENTIALW_to_PCREDENTIALA(CredentialW, NULL, 0);
1376     *Credential = HeapAlloc(GetProcessHeap(), 0, len);
1377     if (!*Credential)
1378     {
1379         SetLastError(ERROR_OUTOFMEMORY);
1380         return FALSE;
1381     }
1382     convert_PCREDENTIALW_to_PCREDENTIALA(CredentialW, *Credential, len);
1383
1384     CredFree(CredentialW);
1385
1386     return TRUE;
1387 }
1388
1389 /******************************************************************************
1390  * CredReadW [ADVAPI32.@]
1391  */
1392 BOOL WINAPI CredReadW(LPCWSTR TargetName, DWORD Type, DWORD Flags, PCREDENTIALW *Credential)
1393 {
1394     HKEY hkeyMgr;
1395     HKEY hkeyCred;
1396     DWORD ret;
1397     LPWSTR key_name;
1398     DWORD len;
1399     BYTE key_data[KEY_SIZE];
1400
1401     TRACE("(%s, %d, 0x%x, %p)\n", debugstr_w(TargetName), Type, Flags, Credential);
1402
1403     if (!TargetName)
1404     {
1405         SetLastError(ERROR_INVALID_PARAMETER);
1406         return FALSE;
1407     }
1408
1409     if (Type != CRED_TYPE_GENERIC && Type != CRED_TYPE_DOMAIN_PASSWORD)
1410     {
1411         FIXME("unhandled type %d\n", Type);
1412         SetLastError(ERROR_INVALID_PARAMETER);
1413         return FALSE;
1414     }
1415
1416     if (Flags)
1417     {
1418         FIXME("unhandled flags 0x%x\n", Flags);
1419         SetLastError(ERROR_INVALID_FLAGS);
1420         return FALSE;
1421     }
1422
1423 #ifdef __APPLE__
1424     if (Type == CRED_TYPE_DOMAIN_PASSWORD)
1425     {
1426         OSStatus status;
1427         SecKeychainSearchRef search;
1428         status = SecKeychainSearchCreateFromAttributes(NULL, kSecGenericPasswordItemClass, NULL, &search);
1429         if (status == noErr)
1430         {
1431             SecKeychainItemRef item;
1432             while (SecKeychainSearchCopyNext(search, &item) == noErr)
1433             {
1434                 SecKeychainAttributeInfo info;
1435                 SecKeychainAttributeList *attr_list;
1436                 UInt32 info_tags[] = { kSecServiceItemAttr };
1437                 LPWSTR target_name;
1438                 INT str_len;
1439                 info.count = sizeof(info_tags)/sizeof(info_tags[0]);
1440                 info.tag = info_tags;
1441                 info.format = NULL;
1442                 status = SecKeychainItemCopyAttributesAndData(item, &info, NULL, &attr_list, NULL, NULL);
1443                 len = sizeof(**Credential);
1444                 if (status != noErr)
1445                 {
1446                     WARN("SecKeychainItemCopyAttributesAndData returned status %ld\n", status);
1447                     continue;
1448                 }
1449                 if (attr_list->count != 1 || attr_list->attr[0].tag != kSecServiceItemAttr)
1450                 {
1451                     CFRelease(item);
1452                     continue;
1453                 }
1454                 str_len = MultiByteToWideChar(CP_UTF8, 0, attr_list->attr[0].data, attr_list->attr[0].length, NULL, 0);
1455                 target_name = HeapAlloc(GetProcessHeap(), 0, (str_len + 1) * sizeof(WCHAR));
1456                 MultiByteToWideChar(CP_UTF8, 0, attr_list->attr[0].data, attr_list->attr[0].length, target_name, str_len);
1457                 /* nul terminate */
1458                 target_name[str_len] = '\0';
1459                 if (strcmpiW(TargetName, target_name))
1460                 {
1461                     CFRelease(item);
1462                     HeapFree(GetProcessHeap(), 0, target_name);
1463                     continue;
1464                 }
1465                 HeapFree(GetProcessHeap(), 0, target_name);
1466                 SecKeychainItemFreeAttributesAndData(attr_list, NULL);
1467                 ret = mac_read_credential_from_item(item, TRUE, NULL, NULL, &len);
1468                 if (ret == ERROR_SUCCESS)
1469                 {
1470                     *Credential = HeapAlloc(GetProcessHeap(), 0, len);
1471                     if (*Credential)
1472                     {
1473                         len = sizeof(**Credential);
1474                         ret = mac_read_credential_from_item(item, TRUE, *Credential,
1475                                                             (char *)(*Credential + 1), &len);
1476                     }
1477                     else
1478                         ret = ERROR_OUTOFMEMORY;
1479                     CFRelease(item);
1480                     CFRelease(search);
1481                     if (ret != ERROR_SUCCESS)
1482                     {
1483                         SetLastError(ret);
1484                         return FALSE;
1485                     }
1486                     return TRUE;
1487                 }
1488                 CFRelease(item);
1489             }
1490             CFRelease(search);
1491         }
1492     }
1493 #endif
1494
1495     ret = open_cred_mgr_key(&hkeyMgr, FALSE);
1496     if (ret != ERROR_SUCCESS)
1497     {
1498         WARN("couldn't open/create manager key, error %d\n", ret);
1499         SetLastError(ERROR_NO_SUCH_LOGON_SESSION);
1500         return FALSE;
1501     }
1502
1503     ret = get_cred_mgr_encryption_key(hkeyMgr, key_data);
1504     if (ret != ERROR_SUCCESS)
1505     {
1506         RegCloseKey(hkeyMgr);
1507         SetLastError(ret);
1508         return FALSE;
1509     }
1510
1511     key_name = get_key_name_for_target(TargetName, Type);
1512     ret = RegOpenKeyExW(hkeyMgr, key_name, 0, KEY_QUERY_VALUE, &hkeyCred);
1513     HeapFree(GetProcessHeap(), 0, key_name);
1514     if (ret != ERROR_SUCCESS)
1515     {
1516         TRACE("credentials for target name %s not found\n", debugstr_w(TargetName));
1517         SetLastError(ERROR_NOT_FOUND);
1518         return FALSE;
1519     }
1520
1521     len = sizeof(**Credential);
1522     ret = registry_read_credential(hkeyCred, NULL, key_data, NULL, &len);
1523     if (ret == ERROR_SUCCESS)
1524     {
1525         *Credential = HeapAlloc(GetProcessHeap(), 0, len);
1526         if (*Credential)
1527         {
1528             len = sizeof(**Credential);
1529             ret = registry_read_credential(hkeyCred, *Credential, key_data,
1530                                            (char *)(*Credential + 1), &len);
1531         }
1532         else
1533             ret = ERROR_OUTOFMEMORY;
1534     }
1535
1536     RegCloseKey(hkeyCred);
1537     RegCloseKey(hkeyMgr);
1538
1539     if (ret != ERROR_SUCCESS)
1540     {
1541         SetLastError(ret);
1542         return FALSE;
1543     }
1544     return TRUE;
1545 }
1546
1547 /******************************************************************************
1548  * CredReadDomainCredentialsA [ADVAPI32.@]
1549  */
1550 BOOL WINAPI CredReadDomainCredentialsA(PCREDENTIAL_TARGET_INFORMATIONA TargetInformation,
1551                                        DWORD Flags, DWORD *Size, PCREDENTIALA **Credentials)
1552 {
1553     PCREDENTIAL_TARGET_INFORMATIONW TargetInformationW;
1554     INT len;
1555     DWORD i;
1556     WCHAR *buffer, *end;
1557     BOOL ret;
1558     PCREDENTIALW* CredentialsW;
1559
1560     TRACE("(%p, 0x%x, %p, %p)\n", TargetInformation, Flags, Size, Credentials);
1561
1562     /* follow Windows behavior - do not test for NULL, initialize early */
1563     *Size = 0;
1564     *Credentials = NULL;
1565
1566     if (!TargetInformation)
1567     {
1568         SetLastError(ERROR_INVALID_PARAMETER);
1569         return FALSE;
1570     }
1571
1572     len = sizeof(*TargetInformationW);
1573     if (TargetInformation->TargetName)
1574         len += MultiByteToWideChar(CP_ACP, 0, TargetInformation->TargetName, -1, NULL, 0) * sizeof(WCHAR);
1575     if (TargetInformation->NetbiosServerName)
1576         len += MultiByteToWideChar(CP_ACP, 0, TargetInformation->NetbiosServerName, -1, NULL, 0) * sizeof(WCHAR);
1577     if (TargetInformation->DnsServerName)
1578         len += MultiByteToWideChar(CP_ACP, 0, TargetInformation->DnsServerName, -1, NULL, 0) * sizeof(WCHAR);
1579     if (TargetInformation->NetbiosDomainName)
1580         len += MultiByteToWideChar(CP_ACP, 0, TargetInformation->NetbiosDomainName, -1, NULL, 0) * sizeof(WCHAR);
1581     if (TargetInformation->DnsDomainName)
1582         len += MultiByteToWideChar(CP_ACP, 0, TargetInformation->DnsDomainName, -1, NULL, 0) * sizeof(WCHAR);
1583     if (TargetInformation->DnsTreeName)
1584         len += MultiByteToWideChar(CP_ACP, 0, TargetInformation->DnsTreeName, -1, NULL, 0) * sizeof(WCHAR);
1585     if (TargetInformation->PackageName)
1586         len += MultiByteToWideChar(CP_ACP, 0, TargetInformation->PackageName, -1, NULL, 0) * sizeof(WCHAR);
1587
1588     TargetInformationW = HeapAlloc(GetProcessHeap(), 0, len);
1589     if (!TargetInformationW)
1590     {
1591         SetLastError(ERROR_OUTOFMEMORY);
1592         return FALSE;
1593     }
1594     buffer = (WCHAR*)(TargetInformationW + 1);
1595     end = (WCHAR *)((char *)TargetInformationW + len);
1596
1597     if (TargetInformation->TargetName)
1598     {
1599         TargetInformationW->TargetName = buffer;
1600         buffer += MultiByteToWideChar(CP_ACP, 0, TargetInformation->TargetName, -1,
1601                                       TargetInformationW->TargetName, end - buffer);
1602     } else
1603         TargetInformationW->TargetName = NULL;
1604
1605     if (TargetInformation->NetbiosServerName)
1606     {
1607         TargetInformationW->NetbiosServerName = buffer;
1608         buffer += MultiByteToWideChar(CP_ACP, 0, TargetInformation->NetbiosServerName, -1,
1609                                       TargetInformationW->NetbiosServerName, end - buffer);
1610     } else
1611         TargetInformationW->NetbiosServerName = NULL;
1612
1613     if (TargetInformation->DnsServerName)
1614     {
1615         TargetInformationW->DnsServerName = buffer;
1616         buffer += MultiByteToWideChar(CP_ACP, 0, TargetInformation->DnsServerName, -1,
1617                                       TargetInformationW->DnsServerName, end - buffer);
1618     } else
1619         TargetInformationW->DnsServerName = NULL;
1620
1621     if (TargetInformation->NetbiosDomainName)
1622     {
1623         TargetInformationW->NetbiosDomainName = buffer;
1624         buffer += MultiByteToWideChar(CP_ACP, 0, TargetInformation->NetbiosDomainName, -1,
1625                                       TargetInformationW->NetbiosDomainName, end - buffer);
1626     } else
1627         TargetInformationW->NetbiosDomainName = NULL;
1628
1629     if (TargetInformation->DnsDomainName)
1630     {
1631         TargetInformationW->DnsDomainName = buffer;
1632         buffer += MultiByteToWideChar(CP_ACP, 0, TargetInformation->DnsDomainName, -1,
1633                                       TargetInformationW->DnsDomainName, end - buffer);
1634     } else
1635         TargetInformationW->DnsDomainName = NULL;
1636
1637     if (TargetInformation->DnsTreeName)
1638     {
1639         TargetInformationW->DnsTreeName = buffer;
1640         buffer += MultiByteToWideChar(CP_ACP, 0, TargetInformation->DnsTreeName, -1,
1641                                       TargetInformationW->DnsTreeName, end - buffer);
1642     } else
1643         TargetInformationW->DnsTreeName = NULL;
1644
1645     if (TargetInformation->PackageName)
1646     {
1647         TargetInformationW->PackageName = buffer;
1648         MultiByteToWideChar(CP_ACP, 0, TargetInformation->PackageName, -1,
1649                             TargetInformationW->PackageName, end - buffer);
1650     } else
1651         TargetInformationW->PackageName = NULL;
1652
1653     TargetInformationW->Flags = TargetInformation->Flags;
1654     TargetInformationW->CredTypeCount = TargetInformation->CredTypeCount;
1655     TargetInformationW->CredTypes = TargetInformation->CredTypes;
1656
1657     ret = CredReadDomainCredentialsW(TargetInformationW, Flags, Size, &CredentialsW);
1658
1659     HeapFree(GetProcessHeap(), 0, TargetInformationW);
1660
1661     if (ret)
1662     {
1663         char *buf;
1664         INT needed;
1665
1666         len = *Size * sizeof(PCREDENTIALA);
1667         for (i = 0; i < *Size; i++)
1668             len += convert_PCREDENTIALW_to_PCREDENTIALA(CredentialsW[i], NULL, 0);
1669
1670         *Credentials = HeapAlloc(GetProcessHeap(), 0, len);
1671         if (!*Credentials)
1672         {
1673             CredFree(CredentialsW);
1674             SetLastError(ERROR_OUTOFMEMORY);
1675             return FALSE;
1676         }
1677
1678         buf = (char *)&(*Credentials)[*Size];
1679         len -= *Size * sizeof(PCREDENTIALA);
1680         for (i = 0; i < *Size; i++)
1681         {
1682             (*Credentials)[i] = (PCREDENTIALA)buf;
1683             needed = convert_PCREDENTIALW_to_PCREDENTIALA(CredentialsW[i], (*Credentials)[i], len);
1684             buf += needed;
1685             len -= needed;
1686         }
1687
1688         CredFree(CredentialsW);
1689     }
1690     return ret;
1691 }
1692
1693 /******************************************************************************
1694  * CredReadDomainCredentialsW [ADVAPI32.@]
1695  */
1696 BOOL WINAPI CredReadDomainCredentialsW(PCREDENTIAL_TARGET_INFORMATIONW TargetInformation, DWORD Flags,
1697                                        DWORD *Size, PCREDENTIALW **Credentials)
1698 {
1699     FIXME("(%p, 0x%x, %p, %p) stub\n", TargetInformation, Flags, Size, Credentials);
1700
1701     /* follow Windows behavior - do not test for NULL, initialize early */
1702     *Size = 0;
1703     *Credentials = NULL;
1704     if (!TargetInformation)
1705     {
1706         SetLastError(ERROR_INVALID_PARAMETER);
1707         return FALSE;
1708     }
1709
1710     SetLastError(ERROR_NOT_FOUND);
1711     return FALSE;
1712 }
1713
1714 /******************************************************************************
1715  * CredWriteA [ADVAPI32.@]
1716  */
1717 BOOL WINAPI CredWriteA(PCREDENTIALA Credential, DWORD Flags)
1718 {
1719     BOOL ret;
1720     INT len;
1721     PCREDENTIALW CredentialW;
1722
1723     TRACE("(%p, 0x%x)\n", Credential, Flags);
1724
1725     if (!Credential || !Credential->TargetName)
1726     {
1727         SetLastError(ERROR_INVALID_PARAMETER);
1728         return FALSE;
1729     }
1730
1731     len = convert_PCREDENTIALA_to_PCREDENTIALW(Credential, NULL, 0);
1732     CredentialW = HeapAlloc(GetProcessHeap(), 0, len);
1733     if (!CredentialW)
1734     {
1735         SetLastError(ERROR_OUTOFMEMORY);
1736         return FALSE;
1737     }
1738
1739     convert_PCREDENTIALA_to_PCREDENTIALW(Credential, CredentialW, len);
1740
1741     ret = CredWriteW(CredentialW, Flags);
1742
1743     HeapFree(GetProcessHeap(), 0, CredentialW);
1744
1745     return ret;
1746 }
1747
1748 /******************************************************************************
1749  * CredWriteW [ADVAPI32.@]
1750  */
1751 BOOL WINAPI CredWriteW(PCREDENTIALW Credential, DWORD Flags)
1752 {
1753     HKEY hkeyMgr;
1754     HKEY hkeyCred;
1755     DWORD ret;
1756     LPWSTR key_name;
1757     BYTE key_data[KEY_SIZE];
1758
1759     TRACE("(%p, 0x%x)\n", Credential, Flags);
1760
1761     if (!Credential || !Credential->TargetName)
1762     {
1763         SetLastError(ERROR_INVALID_PARAMETER);
1764         return FALSE;
1765     }
1766
1767     if (Flags & ~CRED_PRESERVE_CREDENTIAL_BLOB)
1768     {
1769         FIXME("unhandled flags 0x%x\n", Flags);
1770         SetLastError(ERROR_INVALID_FLAGS);
1771         return FALSE;
1772     }
1773
1774     if (Credential->Type != CRED_TYPE_GENERIC && Credential->Type != CRED_TYPE_DOMAIN_PASSWORD)
1775     {
1776         FIXME("unhandled type %d\n", Credential->Type);
1777         SetLastError(ERROR_INVALID_PARAMETER);
1778         return FALSE;
1779     }
1780
1781     TRACE("Credential->Flags = 0x%08x\n", Credential->Flags);
1782     TRACE("Credential->Type = %u\n", Credential->Type);
1783     TRACE("Credential->TargetName = %s\n", debugstr_w(Credential->TargetName));
1784     TRACE("Credential->Comment = %s\n", debugstr_w(Credential->Comment));
1785     TRACE("Credential->Persist = %u\n", Credential->Persist);
1786     TRACE("Credential->TargetAlias = %s\n", debugstr_w(Credential->TargetAlias));
1787     TRACE("Credential->UserName = %s\n", debugstr_w(Credential->UserName));
1788
1789     if (Credential->Type == CRED_TYPE_DOMAIN_PASSWORD)
1790     {
1791         if (!Credential->UserName ||
1792             (Credential->Persist == CRED_PERSIST_ENTERPRISE &&
1793             (!strchrW(Credential->UserName, '\\') && !strchrW(Credential->UserName, '@'))))
1794         {
1795             ERR("bad username %s\n", debugstr_w(Credential->UserName));
1796             SetLastError(ERROR_BAD_USERNAME);
1797             return FALSE;
1798         }
1799     }
1800
1801 #ifdef __APPLE__
1802     if (!Credential->AttributeCount &&
1803         Credential->Type == CRED_TYPE_DOMAIN_PASSWORD &&
1804         (Credential->Persist == CRED_PERSIST_LOCAL_MACHINE || Credential->Persist == CRED_PERSIST_ENTERPRISE))
1805     {
1806         ret = mac_write_credential(Credential, Flags & CRED_PRESERVE_CREDENTIAL_BLOB);
1807         if (ret != ERROR_SUCCESS)
1808         {
1809             SetLastError(ret);
1810             return FALSE;
1811         }
1812         return TRUE;
1813     }
1814 #endif
1815
1816     ret = open_cred_mgr_key(&hkeyMgr, FALSE);
1817     if (ret != ERROR_SUCCESS)
1818     {
1819         WARN("couldn't open/create manager key, error %d\n", ret);
1820         SetLastError(ERROR_NO_SUCH_LOGON_SESSION);
1821         return FALSE;
1822     }
1823
1824     ret = get_cred_mgr_encryption_key(hkeyMgr, key_data);
1825     if (ret != ERROR_SUCCESS)
1826     {
1827         RegCloseKey(hkeyMgr);
1828         SetLastError(ret);
1829         return FALSE;
1830     }
1831
1832     key_name = get_key_name_for_target(Credential->TargetName, Credential->Type);
1833     ret = RegCreateKeyExW(hkeyMgr, key_name, 0, NULL,
1834                           Credential->Persist == CRED_PERSIST_SESSION ? REG_OPTION_VOLATILE : REG_OPTION_NON_VOLATILE,
1835                           KEY_READ|KEY_WRITE, NULL, &hkeyCred, NULL);
1836     HeapFree(GetProcessHeap(), 0, key_name);
1837     if (ret != ERROR_SUCCESS)
1838     {
1839         TRACE("credentials for target name %s not found\n",
1840               debugstr_w(Credential->TargetName));
1841         SetLastError(ERROR_NOT_FOUND);
1842         return FALSE;
1843     }
1844
1845     ret = registry_write_credential(hkeyCred, Credential, key_data,
1846                                     Flags & CRED_PRESERVE_CREDENTIAL_BLOB);
1847
1848     RegCloseKey(hkeyCred);
1849     RegCloseKey(hkeyMgr);
1850
1851     if (ret != ERROR_SUCCESS)
1852     {
1853         SetLastError(ret);
1854         return FALSE;
1855     }
1856     return TRUE;
1857 }
1858
1859 /******************************************************************************
1860  * CredGetSessionTypes [ADVAPI32.@]
1861  */
1862 WINADVAPI BOOL WINAPI CredGetSessionTypes(DWORD persistCount, LPDWORD persists)
1863 {
1864     TRACE("(%u, %p)\n", persistCount, persists);
1865
1866     memset(persists, CRED_PERSIST_NONE, persistCount*sizeof(*persists));
1867     if (CRED_TYPE_GENERIC < persistCount)
1868     {
1869         persists[CRED_TYPE_GENERIC] = CRED_PERSIST_ENTERPRISE;
1870
1871         if (CRED_TYPE_DOMAIN_PASSWORD < persistCount)
1872         {
1873             persists[CRED_TYPE_DOMAIN_PASSWORD] = CRED_PERSIST_ENTERPRISE;
1874         }
1875     }
1876     return TRUE;
1877 }
1878
1879 /******************************************************************************
1880  * CredMarshalCredentialA [ADVAPI32.@]
1881  */
1882 BOOL WINAPI CredMarshalCredentialA( CRED_MARSHAL_TYPE type, PVOID cred, LPSTR *out )
1883 {
1884     BOOL ret;
1885     WCHAR *outW;
1886
1887     TRACE("%u, %p, %p\n", type, cred, out);
1888
1889     if ((ret = CredMarshalCredentialW( type, cred, &outW )))
1890     {
1891         int len = WideCharToMultiByte( CP_ACP, 0, outW, -1, NULL, 0, NULL, NULL );
1892         if (!(*out = HeapAlloc( GetProcessHeap(), 0, len )))
1893         {
1894             HeapFree( GetProcessHeap(), 0, outW );
1895             return FALSE;
1896         }
1897         WideCharToMultiByte( CP_ACP, 0, outW, -1, *out, len, NULL, NULL );
1898         HeapFree( GetProcessHeap(), 0, outW );
1899     }
1900     return ret;
1901 }
1902
1903 static UINT cred_encode( const char *bin, unsigned int len, WCHAR *cred )
1904 {
1905     static const char enc[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789#-";
1906     UINT n = 0, x;
1907
1908     while (len > 0)
1909     {
1910         cred[n++] = enc[bin[0] & 0x3f];
1911         x = (bin[0] & 0xc0) >> 6;
1912         if (len == 1)
1913         {
1914             cred[n++] = enc[x];
1915             break;
1916         }
1917         cred[n++] = enc[((bin[1] & 0xf) << 2) | x];
1918         x = (bin[1] & 0xf0) >> 4;
1919         if (len == 2)
1920         {
1921             cred[n++] = enc[x];
1922             break;
1923         }
1924         cred[n++] = enc[((bin[2] & 0x3) << 4) | x];
1925         cred[n++] = enc[(bin[2] & 0xfc) >> 2];
1926         bin += 3;
1927         len -= 3;
1928     }
1929     return n;
1930 }
1931
1932 /******************************************************************************
1933  * CredMarshalCredentialW [ADVAPI32.@]
1934  */
1935 BOOL WINAPI CredMarshalCredentialW( CRED_MARSHAL_TYPE type, PVOID cred, LPWSTR *out )
1936 {
1937     CERT_CREDENTIAL_INFO *cert = cred;
1938     USERNAME_TARGET_CREDENTIAL_INFO *target = cred;
1939     DWORD len, size;
1940     WCHAR *p;
1941
1942     TRACE("%u, %p, %p\n", type, cred, out);
1943
1944     if (!cred || (type == CertCredential && cert->cbSize < sizeof(*cert)) ||
1945         (type != CertCredential && type != UsernameTargetCredential && type != BinaryBlobCredential) ||
1946         (type == UsernameTargetCredential && (!target->UserName || !target->UserName[0])))
1947     {
1948         SetLastError( ERROR_INVALID_PARAMETER );
1949         return FALSE;
1950     }
1951     switch (type)
1952     {
1953     case CertCredential:
1954     {
1955         char hash[CERT_HASH_LENGTH + 2];
1956
1957         memcpy( hash, cert->rgbHashOfCert, sizeof(cert->rgbHashOfCert) );
1958         memset( hash + sizeof(cert->rgbHashOfCert), 0, sizeof(hash) - sizeof(cert->rgbHashOfCert) );
1959
1960         size = sizeof(hash) * 4 / 3;
1961         if (!(p = HeapAlloc( GetProcessHeap(), 0, (size + 4) * sizeof(WCHAR) ))) return FALSE;
1962         p[0] = '@';
1963         p[1] = '@';
1964         p[2] = 'A' + type;
1965         len = cred_encode( (const char *)hash, sizeof(hash), p + 3 );
1966         p[len] = 0;
1967         break;
1968     }
1969     case UsernameTargetCredential:
1970     {
1971         len = strlenW( target->UserName );
1972         size = (sizeof(DWORD) + len * sizeof(WCHAR) + 2) * 4 / 3;
1973         if (!(p = HeapAlloc( GetProcessHeap(), 0, (size + 4) * sizeof(WCHAR) ))) return FALSE;
1974         p[0] = '@';
1975         p[1] = '@';
1976         p[2] = 'A' + type;
1977         size = len * sizeof(WCHAR);
1978         len = cred_encode( (const char *)&size, sizeof(DWORD), p + 3 );
1979         len += cred_encode( (const char *)target->UserName, size, p + 3 + len );
1980         p[len + 3] = 0;
1981         break;
1982     }
1983     case BinaryBlobCredential:
1984         FIXME("BinaryBlobCredential not implemented\n");
1985         return FALSE;
1986     default:
1987         return FALSE;
1988     }
1989     *out = p;
1990     return TRUE;
1991 }
1992
1993 /******************************************************************************
1994  * CredUnmarshalCredentialA [ADVAPI32.@]
1995  */
1996 BOOL WINAPI CredUnmarshalCredentialA( LPCSTR cred, PCRED_MARSHAL_TYPE type, PVOID *out )
1997 {
1998     BOOL ret;
1999     WCHAR *credW = NULL;
2000
2001     TRACE("%s, %p, %p\n", debugstr_a(cred), type, out);
2002
2003     if (cred)
2004     {
2005         int len = MultiByteToWideChar( CP_ACP, 0, cred, -1, NULL, 0 );
2006         if (!(credW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return FALSE;
2007         MultiByteToWideChar( CP_ACP, 0, cred, -1, credW, len );
2008     }
2009     ret = CredUnmarshalCredentialW( credW, type, out );
2010     HeapFree( GetProcessHeap(), 0, credW );
2011     return ret;
2012 }
2013
2014 static inline char char_decode( WCHAR c )
2015 {
2016     if (c >= 'A' && c <= 'Z') return c - 'A';
2017     if (c >= 'a' && c <= 'z') return c - 'a' + 26;
2018     if (c >= '0' && c <= '9') return c - '0' + 52;
2019     if (c == '#') return 62;
2020     if (c == '-') return 63;
2021     return 64;
2022 }
2023
2024 static BOOL cred_decode( const WCHAR *cred, unsigned int len, char *buf )
2025 {
2026     unsigned int i = 0;
2027     char c0, c1, c2, c3;
2028     const WCHAR *p = cred;
2029
2030     while (len >= 4)
2031     {
2032         if ((c0 = char_decode( p[0] )) > 63) return FALSE;
2033         if ((c1 = char_decode( p[1] )) > 63) return FALSE;
2034         if ((c2 = char_decode( p[2] )) > 63) return FALSE;
2035         if ((c3 = char_decode( p[3] )) > 63) return FALSE;
2036
2037         buf[i + 0] = (c1 << 6) | c0;
2038         buf[i + 1] = (c2 << 4) | (c1 >> 2);
2039         buf[i + 2] = (c3 << 2) | (c2 >> 4);
2040         len -= 4;
2041         i += 3;
2042         p += 4;
2043     }
2044     if (len == 3)
2045     {
2046         if ((c0 = char_decode( p[0] )) > 63) return FALSE;
2047         if ((c1 = char_decode( p[1] )) > 63) return FALSE;
2048         if ((c2 = char_decode( p[2] )) > 63) return FALSE;
2049
2050         buf[i + 0] = (c1 << 6) | c0;
2051         buf[i + 1] = (c2 << 4) | (c1 >> 2);
2052     }
2053     else if (len == 2)
2054     {
2055         if ((c0 = char_decode( p[0] )) > 63) return FALSE;
2056         if ((c1 = char_decode( p[1] )) > 63) return FALSE;
2057
2058         buf[i + 0] = (c1 << 6) | c0;
2059     }
2060     else if (len == 1)
2061     {
2062         return FALSE;
2063     }
2064     return TRUE;
2065 }
2066
2067 /******************************************************************************
2068  * CredUnmarshalCredentialW [ADVAPI32.@]
2069  */
2070 BOOL WINAPI CredUnmarshalCredentialW( LPCWSTR cred, PCRED_MARSHAL_TYPE type, PVOID *out )
2071 {
2072     unsigned int len, buflen;
2073
2074     TRACE("%s, %p, %p\n", debugstr_w(cred), type, out);
2075
2076     if (!cred || cred[0] != '@' || cred[1] != '@' || !cred[2] || !cred[3])
2077     {
2078         SetLastError( ERROR_INVALID_PARAMETER );
2079         return FALSE;
2080     }
2081     len = strlenW( cred + 3 );
2082     switch (cred[2] - 'A')
2083     {
2084     case CertCredential:
2085     {
2086         char hash[CERT_HASH_LENGTH];
2087         CERT_CREDENTIAL_INFO *cert;
2088
2089         if (len != 27 || !cred_decode( cred + 3, len, hash ))
2090         {
2091             SetLastError( ERROR_INVALID_PARAMETER );
2092             return FALSE;
2093         }
2094         if (!(cert = HeapAlloc( GetProcessHeap(), 0, sizeof(*cert) ))) return FALSE;
2095         memcpy( cert->rgbHashOfCert, hash, sizeof(cert->rgbHashOfCert) );
2096         cert->cbSize = sizeof(*cert);
2097         *type = CertCredential;
2098         *out = cert;
2099         break;
2100     }
2101     case UsernameTargetCredential:
2102     {
2103         USERNAME_TARGET_CREDENTIAL_INFO *target;
2104         DWORD size;
2105
2106         if (len < 9 || !cred_decode( cred + 3, 6, (char *)&size ) ||
2107             !size || size % sizeof(WCHAR) || size > INT_MAX)
2108         {
2109             SetLastError( ERROR_INVALID_PARAMETER );
2110             return FALSE;
2111         }
2112         buflen = sizeof(*target) + size + sizeof(WCHAR);
2113         if (!(target = HeapAlloc( GetProcessHeap(), 0, buflen ))) return FALSE;
2114         if (!cred_decode( cred + 9, len - 6, (char *)(target + 1) ))
2115         {
2116             HeapFree( GetProcessHeap(), 0, target );
2117             return FALSE;
2118         }
2119         target->UserName = (WCHAR *)(target + 1);
2120         target->UserName[size / sizeof(WCHAR)] = 0;
2121         *type = UsernameTargetCredential;
2122         *out = target;
2123         break;
2124     }
2125     case BinaryBlobCredential:
2126         FIXME("BinaryBlobCredential not implemented\n");
2127         return FALSE;
2128     default:
2129         WARN("unhandled type %u\n", cred[2] - 'A');
2130         return FALSE;
2131     }
2132     return TRUE;
2133 }
2134
2135 /******************************************************************************
2136  * CredIsMarshaledCredentialW [ADVAPI32.@]
2137  *
2138  * Check, if the name parameter is a marshaled credential, hash or binary blob
2139  *
2140  * PARAMS
2141  *  name    the name to check
2142  *
2143  * RETURNS
2144  *  TRUE:  the name parameter is a marshaled credential, hash or binary blob
2145  *  FALSE: the name is a plain username
2146  */
2147 BOOL WINAPI CredIsMarshaledCredentialW(LPCWSTR name)
2148 {
2149     TRACE("(%s)\n", debugstr_w(name));
2150
2151     if (name && name[0] == '@' && name[1] == '@' && name[2] > 'A' && name[3])
2152     {
2153         char hash[CERT_HASH_LENGTH];
2154         int len = strlenW(name + 3 );
2155         DWORD size;
2156
2157         if ((name[2] - 'A') == CertCredential && (len == 27) && cred_decode(name + 3, len, hash))
2158             return TRUE;
2159
2160         if (((name[2] - 'A') == UsernameTargetCredential) &&
2161             (len >= 9) && cred_decode(name + 3, 6, (char *)&size) && size)
2162             return TRUE;
2163
2164         if ((name[2] - 'A') == BinaryBlobCredential)
2165             FIXME("BinaryBlobCredential not checked\n");
2166
2167         if ((name[2] - 'A') > BinaryBlobCredential)
2168             TRACE("unknown type: %d\n", (name[2] - 'A'));
2169     }
2170
2171     SetLastError(ERROR_INVALID_PARAMETER);
2172     return FALSE;
2173 }
2174
2175 /******************************************************************************
2176  * CredIsMarshaledCredentialA [ADVAPI32.@]
2177  *
2178  * See CredIsMarshaledCredentialW
2179  *
2180  */
2181 BOOL WINAPI CredIsMarshaledCredentialA(LPCSTR name)
2182 {
2183     LPWSTR nameW = NULL;
2184     BOOL res;
2185     int len;
2186
2187     TRACE("(%s)\n", debugstr_a(name));
2188
2189     if (name)
2190     {
2191         len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0);
2192         nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2193         MultiByteToWideChar(CP_ACP, 0, name, -1, nameW, len);
2194     }
2195
2196     res = CredIsMarshaledCredentialW(nameW);
2197     HeapFree(GetProcessHeap(), 0, nameW);
2198     return res;
2199 }