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