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