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