dlls/advapi32/tests/cred.c

   1 /*
   2  * Credential Function Tests
   3  *
   4  * Copyright 2007 Robert Shearman
   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 <stdio.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "wincred.h"
  27
  28 #include "wine/test.h"
  29
  30 #define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
  31
  32 static BOOL (WINAPI *pCredDeleteA)(LPCSTR,DWORD,DWORD);
  33 static BOOL (WINAPI *pCredEnumerateA)(LPCSTR,DWORD,DWORD *,PCREDENTIALA **);
  34 static VOID (WINAPI *pCredFree)(PVOID);
  35 static BOOL (WINAPI *pCredGetSessionTypes)(DWORD,LPDWORD);
  36 static BOOL (WINAPI *pCredReadA)(LPCSTR,DWORD,DWORD,PCREDENTIALA *);
  37 static BOOL (WINAPI *pCredRenameA)(LPCSTR,LPCSTR,DWORD,DWORD);
  38 static BOOL (WINAPI *pCredWriteA)(PCREDENTIALA,DWORD);
  39 static BOOL (WINAPI *pCredReadDomainCredentialsA)(PCREDENTIAL_TARGET_INFORMATIONA,DWORD,DWORD*,PCREDENTIALA**);
  40 static BOOL (WINAPI *pCredMarshalCredentialA)(CRED_MARSHAL_TYPE,PVOID,LPSTR *);
  41 static BOOL (WINAPI *pCredUnmarshalCredentialA)(LPCSTR,PCRED_MARSHAL_TYPE,PVOID);
  42 static BOOL (WINAPI *pCredIsMarshaledCredentialA)(LPCSTR);
  43
  44 #define TEST_TARGET_NAME  "credtest.winehq.org"
  45 #define TEST_TARGET_NAME2 "credtest2.winehq.org"
  46 static const WCHAR TEST_PASSWORD[] = {'p','4','$','$','w','0','r','d','!',0};
  47
  48 static void test_CredReadA(void)
  49 {
  50     BOOL ret;
  51     PCREDENTIALA cred;
  52
  53     SetLastError(0xdeadbeef);
  54     ret = pCredReadA(TEST_TARGET_NAME, -1, 0, &cred);
  55     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
  56         "CredReadA should have failed with ERROR_INVALID_PARAMETER instead of %d\n",
  57         GetLastError());
  58
  59     SetLastError(0xdeadbeef);
  60     ret = pCredReadA(TEST_TARGET_NAME, CRED_TYPE_GENERIC, 0xdeadbeef, &cred);
  61     ok(!ret && ( GetLastError() == ERROR_INVALID_FLAGS || GetLastError() == ERROR_INVALID_PARAMETER ),
  62         "CredReadA should have failed with ERROR_INVALID_FLAGS or ERROR_INVALID_PARAMETER instead of %d\n",
  63         GetLastError());
  64
  65     SetLastError(0xdeadbeef);
  66     ret = pCredReadA(NULL, CRED_TYPE_GENERIC, 0, &cred);
  67     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
  68         "CredReadA should have failed with ERROR_INVALID_PARAMETER instead of %d\n",
  69         GetLastError());
  70 }
  71
  72 static void test_CredWriteA(void)
  73 {
  74     CREDENTIALA new_cred;
  75     BOOL ret;
  76
  77     SetLastError(0xdeadbeef);
  78     ret = pCredWriteA(NULL, 0);
  79     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
  80         "CredWriteA should have failed with ERROR_INVALID_PARAMETER instead of %d\n",
  81         GetLastError());
  82
  83     new_cred.Flags = 0;
  84     new_cred.Type = CRED_TYPE_GENERIC;
  85     new_cred.TargetName = NULL;
  86     new_cred.Comment = (char *)"Comment";
  87     new_cred.CredentialBlobSize = 0;
  88     new_cred.CredentialBlob = NULL;
  89     new_cred.Persist = CRED_PERSIST_ENTERPRISE;
  90     new_cred.AttributeCount = 0;
  91     new_cred.Attributes = NULL;
  92     new_cred.TargetAlias = NULL;
  93     new_cred.UserName = (char *)"winetest";
  94
  95     SetLastError(0xdeadbeef);
  96     ret = pCredWriteA(&new_cred, 0);
  97     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
  98         "CredWriteA should have failed with ERROR_INVALID_PARAMETER instead of %d\n",
  99         GetLastError());
 100
 101     new_cred.TargetName = (char *)TEST_TARGET_NAME;
 102     new_cred.Type = CRED_TYPE_DOMAIN_PASSWORD;
 103
 104     SetLastError(0xdeadbeef);
 105     ret = pCredWriteA(&new_cred, 0);
 106     if (ret)
 107     {
 108         ok(GetLastError() == ERROR_SUCCESS ||
 109            GetLastError() == ERROR_IO_PENDING, /* Vista */
 110            "Expected ERROR_IO_PENDING, got %d\n", GetLastError());
 111     }
 112     else
 113     {
 114         ok(GetLastError() == ERROR_BAD_USERNAME ||
 115            GetLastError() == ERROR_NO_SUCH_LOGON_SESSION, /* Vista */
 116            "CredWrite with username without domain should return ERROR_BAD_USERNAME"
 117            "or ERROR_NO_SUCH_LOGON_SESSION not %d\n", GetLastError());
 118     }
 119
 120     new_cred.UserName = NULL;
 121     SetLastError(0xdeadbeef);
 122     ret = pCredWriteA(&new_cred, 0);
 123     ok(!ret && GetLastError() == ERROR_BAD_USERNAME,
 124         "CredWriteA with NULL username should have failed with ERROR_BAD_USERNAME instead of %d\n",
 125         GetLastError());
 126
 127     new_cred.UserName = (char *)"winetest";
 128     new_cred.Persist = CRED_PERSIST_LOCAL_MACHINE;
 129     SetLastError(0xdeadbeef);
 130     ret = pCredWriteA(&new_cred, 0);
 131     ok(ret || broken(!ret), "CredWriteA failed with error %u\n", GetLastError());
 132     if (ret)
 133     {
 134         ret = pCredDeleteA(TEST_TARGET_NAME, CRED_TYPE_DOMAIN_PASSWORD, 0);
 135         ok(ret, "CredDeleteA failed with error %u\n", GetLastError());
 136     }
 137     new_cred.Type = CRED_TYPE_GENERIC;
 138     SetLastError(0xdeadbeef);
 139     ret = pCredWriteA(&new_cred, 0);
 140     ok(ret || broken(!ret), "CredWriteA failed with error %u\n", GetLastError());
 141     if  (ret)
 142     {
 143         ret = pCredDeleteA(TEST_TARGET_NAME, CRED_TYPE_GENERIC, 0);
 144         ok(ret, "CredDeleteA failed with error %u\n", GetLastError());
 145     }
 146     new_cred.Persist = CRED_PERSIST_SESSION;
 147     ret = pCredWriteA(&new_cred, 0);
 148     ok(ret, "CredWriteA failed with error %u\n", GetLastError());
 149
 150     ret = pCredDeleteA(TEST_TARGET_NAME, CRED_TYPE_GENERIC, 0);
 151     ok(ret, "CredDeleteA failed with error %u\n", GetLastError());
 152
 153     new_cred.Type = CRED_TYPE_DOMAIN_PASSWORD;
 154     SetLastError(0xdeadbeef);
 155     ret = pCredWriteA(&new_cred, 0);
 156     ok(ret || broken(!ret), "CredWriteA failed with error %u\n", GetLastError());
 157     if (ret)
 158     {
 159         ret = pCredDeleteA(TEST_TARGET_NAME, CRED_TYPE_DOMAIN_PASSWORD, 0);
 160         ok(ret, "CredDeleteA failed with error %u\n", GetLastError());
 161     }
 162     new_cred.UserName = NULL;
 163     SetLastError(0xdeadbeef);
 164     ret = pCredWriteA(&new_cred, 0);
 165     ok(!ret, "CredWriteA succeeded\n");
 166     ok(GetLastError() == ERROR_BAD_USERNAME, "got %u\n", GetLastError());
 167 }
 168
 169 static void test_CredDeleteA(void)
 170 {
 171     BOOL ret;
 172
 173     SetLastError(0xdeadbeef);
 174     ret = pCredDeleteA(TEST_TARGET_NAME, -1, 0);
 175     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 176         "CredDeleteA should have failed with ERROR_INVALID_PARAMETER instead of %d\n",
 177         GetLastError());
 178
 179     SetLastError(0xdeadbeef);
 180     ret = pCredDeleteA(TEST_TARGET_NAME, CRED_TYPE_GENERIC, 0xdeadbeef);
 181     ok(!ret && ( GetLastError() == ERROR_INVALID_FLAGS || GetLastError() == ERROR_INVALID_PARAMETER /* Vista */ ),
 182         "CredDeleteA should have failed with ERROR_INVALID_FLAGS or ERROR_INVALID_PARAMETER instead of %d\n",
 183         GetLastError());
 184 }
 185
 186 static void test_CredReadDomainCredentialsA(void)
 187 {
 188     BOOL ret;
 189     char target_name[] = "no_such_target";
 190     CREDENTIAL_TARGET_INFORMATIONA info = {target_name, NULL, target_name, NULL, NULL, NULL, NULL, 0, 0, NULL};
 191     DWORD count;
 192     PCREDENTIALA* creds;
 193
 194     if (!pCredReadDomainCredentialsA)
 195     {
 196         win_skip("CredReadDomainCredentialsA() is not implemented\n");
 197         return;
 198     }
 199
 200     /* these two tests would crash on both native and Wine. Implementations
 201      * does not check for NULL output pointers and try to zero them out early */
 202 if(0)
 203 {
 204     ret = pCredReadDomainCredentialsA(&info, 0, NULL, &creds);
 205     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "!\n");
 206     ret = pCredReadDomainCredentialsA(&info, 0, &count, NULL);
 207     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "!\n");
 208 }
 209
 210     SetLastError(0xdeadbeef);
 211     ret = pCredReadDomainCredentialsA(NULL, 0, &count, &creds);
 212     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 213         "CredReadDomainCredentialsA should have failed with ERROR_INVALID_PARAMETER instead of %d\n",
 214         GetLastError());
 215
 216     SetLastError(0xdeadbeef);
 217     creds = (void*)0x12345;
 218     count = 2;
 219     ret = pCredReadDomainCredentialsA(&info, 0, &count, &creds);
 220     ok(!ret && GetLastError() == ERROR_NOT_FOUND,
 221         "CredReadDomainCredentialsA should have failed with ERROR_NOT_FOUND instead of %d\n",
 222         GetLastError());
 223     ok(count ==0 && creds == NULL, "CredReadDomainCredentialsA must not return any result\n");
 224
 225     info.TargetName = NULL;
 226
 227     SetLastError(0xdeadbeef);
 228     ret = pCredReadDomainCredentialsA(&info, 0, &count, &creds);
 229     ok(!ret, "CredReadDomainCredentialsA should have failed\n");
 230     ok(GetLastError() == ERROR_NOT_FOUND ||
 231         GetLastError() == ERROR_INVALID_PARAMETER, /* Vista, W2K8 */
 232         "Expected ERROR_NOT_FOUND or ERROR_INVALID_PARAMETER instead of %d\n",
 233         GetLastError());
 234
 235     info.DnsServerName = NULL;
 236
 237     SetLastError(0xdeadbeef);
 238     ret = pCredReadDomainCredentialsA(&info, 0, &count, &creds);
 239     ok(!ret, "CredReadDomainCredentialsA should have failed\n");
 240     ok(GetLastError() == ERROR_NOT_FOUND ||
 241         GetLastError() == ERROR_INVALID_PARAMETER, /* Vista, W2K8 */
 242         "Expected ERROR_NOT_FOUND or ERROR_INVALID_PARAMETER instead of %d\n",
 243         GetLastError());
 244 }
 245
 246 static void check_blob(int line, DWORD cred_type, PCREDENTIALA cred)
 247 {
 248     if (cred_type == CRED_TYPE_DOMAIN_PASSWORD)
 249     {
 250         todo_wine
 251         ok_(__FILE__, line)(cred->CredentialBlobSize == 0, "expected CredentialBlobSize of 0 but got %d\n", cred->CredentialBlobSize);
 252         todo_wine
 253         ok_(__FILE__, line)(!cred->CredentialBlob, "expected NULL credentials but got %p\n", cred->CredentialBlob);
 254     }
 255     else
 256     {
 257         DWORD size=sizeof(TEST_PASSWORD);
 258         ok_(__FILE__, line)(cred->CredentialBlobSize == size, "expected CredentialBlobSize of %u but got %u\n", size, cred->CredentialBlobSize);
 259         ok_(__FILE__, line)(cred->CredentialBlob != NULL, "CredentialBlob should be present\n");
 260         if (cred->CredentialBlob)
 261             ok_(__FILE__, line)(!memcmp(cred->CredentialBlob, TEST_PASSWORD, size), "wrong CredentialBlob\n");
 262     }
 263 }
 264
 265 static void test_generic(void)
 266 {
 267     BOOL ret;
 268     DWORD count, i;
 269     PCREDENTIALA *creds;
 270     CREDENTIALA new_cred;
 271     PCREDENTIALA cred;
 272     BOOL found = FALSE;
 273
 274     new_cred.Flags = 0;
 275     new_cred.Type = CRED_TYPE_GENERIC;
 276     new_cred.TargetName = (char *)TEST_TARGET_NAME;
 277     new_cred.Comment = (char *)"Comment";
 278     new_cred.CredentialBlobSize = sizeof(TEST_PASSWORD);
 279     new_cred.CredentialBlob = (LPBYTE)TEST_PASSWORD;
 280     new_cred.Persist = CRED_PERSIST_ENTERPRISE;
 281     new_cred.AttributeCount = 0;
 282     new_cred.Attributes = NULL;
 283     new_cred.TargetAlias = NULL;
 284     new_cred.UserName = (char *)"winetest";
 285
 286     ret = pCredWriteA(&new_cred, 0);
 287     ok(ret || broken(GetLastError() == ERROR_NO_SUCH_LOGON_SESSION),
 288        "CredWriteA failed with error %d\n", GetLastError());
 289     if (!ret)
 290     {
 291         skip("couldn't write generic credentials, skipping tests\n");
 292         return;
 293     }
 294
 295     ret = pCredEnumerateA(NULL, 0, &count, &creds);
 296     ok(ret, "CredEnumerateA failed with error %d\n", GetLastError());
 297
 298     for (i = 0; i < count; i++)
 299     {
 300         if (creds[i]->TargetName && !strcmp(creds[i]->TargetName, TEST_TARGET_NAME))
 301         {
 302             ok(creds[i]->Type == CRED_TYPE_GENERIC ||
 303                creds[i]->Type == CRED_TYPE_DOMAIN_PASSWORD, /* Vista */
 304                "expected creds[%d]->Type CRED_TYPE_GENERIC or CRED_TYPE_DOMAIN_PASSWORD but got %d\n", i, creds[i]->Type);
 305             ok(!creds[i]->Flags, "expected creds[%d]->Flags 0 but got 0x%x\n", i, creds[i]->Flags);
 306             ok(!strcmp(creds[i]->Comment, "Comment"), "expected creds[%d]->Comment \"Comment\" but got \"%s\"\n", i, creds[i]->Comment);
 307             check_blob(__LINE__, creds[i]->Type, creds[i]);
 308             ok(creds[i]->Persist, "expected creds[%d]->Persist CRED_PERSIST_ENTERPRISE but got %d\n", i, creds[i]->Persist);
 309             ok(!strcmp(creds[i]->UserName, "winetest"), "expected creds[%d]->UserName \"winetest\" but got \"%s\"\n", i, creds[i]->UserName);
 310             found = TRUE;
 311         }
 312     }
 313     pCredFree(creds);
 314     ok(found, "credentials not found\n");
 315
 316     ret = pCredReadA(TEST_TARGET_NAME, CRED_TYPE_GENERIC, 0, &cred);
 317     ok(ret, "CredReadA failed with error %d\n", GetLastError());
 318     pCredFree(cred);
 319
 320     ret = pCredDeleteA(TEST_TARGET_NAME, CRED_TYPE_GENERIC, 0);
 321     ok(ret, "CredDeleteA failed with error %d\n", GetLastError());
 322 }
 323
 324 static void test_domain_password(DWORD cred_type)
 325 {
 326     BOOL ret;
 327     DWORD count, i;
 328     PCREDENTIALA *creds;
 329     CREDENTIALA new_cred;
 330     PCREDENTIALA cred;
 331     BOOL found = FALSE;
 332
 333     new_cred.Flags = 0;
 334     new_cred.Type = cred_type;
 335     new_cred.TargetName = (char *)TEST_TARGET_NAME;
 336     new_cred.Comment = (char *)"Comment";
 337     new_cred.CredentialBlobSize = sizeof(TEST_PASSWORD);
 338     new_cred.CredentialBlob = (LPBYTE)TEST_PASSWORD;
 339     new_cred.Persist = CRED_PERSIST_ENTERPRISE;
 340     new_cred.AttributeCount = 0;
 341     new_cred.Attributes = NULL;
 342     new_cred.TargetAlias = NULL;
 343     new_cred.UserName = (char *)"test\\winetest";
 344     ret = pCredWriteA(&new_cred, 0);
 345     if (!ret && GetLastError() == ERROR_NO_SUCH_LOGON_SESSION)
 346     {
 347         skip("CRED_TYPE_DOMAIN_PASSWORD credentials are not supported "
 348              "or are disabled. Skipping\n");
 349         return;
 350     }
 351     ok(ret, "CredWriteA failed with error %d\n", GetLastError());
 352
 353     ret = pCredEnumerateA(NULL, 0, &count, &creds);
 354     ok(ret, "CredEnumerateA failed with error %d\n", GetLastError());
 355
 356     for (i = 0; i < count; i++)
 357     {
 358         if (creds[i]->TargetName && !strcmp(creds[i]->TargetName, TEST_TARGET_NAME))
 359         {
 360             ok(creds[i]->Type == cred_type, "expected creds[%d]->Type CRED_TYPE_DOMAIN_PASSWORD but got %d\n", i, creds[i]->Type);
 361             ok(!creds[i]->Flags, "expected creds[%d]->Flags 0 but got 0x%x\n", i, creds[i]->Flags);
 362             ok(!strcmp(creds[i]->Comment, "Comment"), "expected creds[%d]->Comment \"Comment\" but got \"%s\"\n", i, creds[i]->Comment);
 363             check_blob(__LINE__, cred_type, creds[i]);
 364             ok(creds[i]->Persist, "expected creds[%d]->Persist CRED_PERSIST_ENTERPRISE but got %d\n", i, creds[i]->Persist);
 365             ok(!strcmp(creds[i]->UserName, "test\\winetest"), "expected creds[%d]->UserName \"winetest\" but got \"%s\"\n", i, creds[i]->UserName);
 366             found = TRUE;
 367         }
 368     }
 369     pCredFree(creds);
 370     ok(found, "credentials not found\n");
 371
 372     ret = pCredReadA(TEST_TARGET_NAME, cred_type, 0, &cred);
 373     ok(ret, "CredReadA failed with error %d\n", GetLastError());
 374     if (ret)  /* don't check the values of cred, if CredReadA failed. */
 375     {
 376         check_blob(__LINE__, cred_type, cred);
 377         pCredFree(cred);
 378     }
 379
 380     ret = pCredDeleteA(TEST_TARGET_NAME, cred_type, 0);
 381     ok(ret, "CredDeleteA failed with error %d\n", GetLastError());
 382 }
 383
 384 static void test_CredMarshalCredentialA(void)
 385 {
 386     static WCHAR emptyW[] = {0};
 387     static WCHAR tW[] = {'t',0};
 388     static WCHAR teW[] = {'t','e',0};
 389     static WCHAR tesW[] = {'t','e','s',0};
 390     static WCHAR testW[] = {'t','e','s','t',0};
 391     static WCHAR test1W[] = {'t','e','s','t','1',0};
 392     CERT_CREDENTIAL_INFO cert;
 393     USERNAME_TARGET_CREDENTIAL_INFO username;
 394     DWORD error;
 395     char *str;
 396     BOOL ret;
 397
 398     SetLastError( 0xdeadbeef );
 399     ret = pCredMarshalCredentialA( 0, NULL, NULL );
 400     error = GetLastError();
 401     ok( !ret, "unexpected success\n" );
 402     ok( error == ERROR_INVALID_PARAMETER, "got %u\n", error );
 403
 404     memset( cert.rgbHashOfCert, 0, sizeof(cert.rgbHashOfCert) );
 405     cert.cbSize = sizeof(cert);
 406     SetLastError( 0xdeadbeef );
 407     ret = pCredMarshalCredentialA( 0, &cert, NULL );
 408     error = GetLastError();
 409     ok( !ret, "unexpected success\n" );
 410     ok( error == ERROR_INVALID_PARAMETER, "got %u\n", error );
 411
 412     str = (char *)0xdeadbeef;
 413     SetLastError( 0xdeadbeef );
 414     ret = pCredMarshalCredentialA( 0, &cert, &str );
 415     error = GetLastError();
 416     ok( !ret, "unexpected success\n" );
 417     ok( error == ERROR_INVALID_PARAMETER, "got %u\n", error );
 418     ok( str == (char *)0xdeadbeef, "got %p\n", str );
 419
 420     SetLastError( 0xdeadbeef );
 421     ret = pCredMarshalCredentialA( CertCredential, NULL, NULL );
 422     error = GetLastError();
 423     ok( !ret, "unexpected success\n" );
 424     ok( error == ERROR_INVALID_PARAMETER, "got %u\n", error );
 425
 426     if (0) { /* crash */
 427     SetLastError( 0xdeadbeef );
 428     ret = pCredMarshalCredentialA( CertCredential, &cert, NULL );
 429     error = GetLastError();
 430     ok( !ret, "unexpected success\n" );
 431     ok( error == ERROR_INVALID_PARAMETER, "got %u\n", error );
 432     }
 433
 434     cert.cbSize = 0;
 435     str = (char *)0xdeadbeef;
 436     SetLastError( 0xdeadbeef );
 437     ret = pCredMarshalCredentialA( CertCredential, &cert, &str );
 438     error = GetLastError();
 439     ok( !ret, "unexpected success\n" );
 440     ok( error == ERROR_INVALID_PARAMETER, "got %u\n", error );
 441     ok( str == (char *)0xdeadbeef, "got %p\n", str );
 442
 443     cert.cbSize = sizeof(cert) + 4;
 444     str = NULL;
 445     ret = pCredMarshalCredentialA( CertCredential, &cert, &str );
 446     ok( ret, "unexpected failure %u\n", GetLastError() );
 447     ok( str != NULL, "str not set\n" );
 448     ok( !lstrcmpA( str, "@@BAAAAAAAAAAAAAAAAAAAAAAAAAAA" ), "got %s\n", str );
 449     pCredFree( str );
 450
 451     cert.cbSize = sizeof(cert);
 452     cert.rgbHashOfCert[0] = 2;
 453     str = NULL;
 454     ret = pCredMarshalCredentialA( CertCredential, &cert, &str );
 455     ok( ret, "unexpected failure %u\n", GetLastError() );
 456     ok( str != NULL, "str not set\n" );
 457     ok( !lstrcmpA( str, "@@BCAAAAAAAAAAAAAAAAAAAAAAAAAA" ), "got %s\n", str );
 458     pCredFree( str );
 459
 460     cert.rgbHashOfCert[0] = 255;
 461     str = NULL;
 462     ret = pCredMarshalCredentialA( CertCredential, &cert, &str );
 463     ok( ret, "unexpected failure %u\n", GetLastError() );
 464     ok( str != NULL, "str not set\n" );
 465     ok( !lstrcmpA( str, "@@B-DAAAAAAAAAAAAAAAAAAAAAAAAA" ), "got %s\n", str );
 466     pCredFree( str );
 467
 468     cert.rgbHashOfCert[0] = 1;
 469     cert.rgbHashOfCert[1] = 1;
 470     str = NULL;
 471     ret = pCredMarshalCredentialA( CertCredential, &cert, &str );
 472     ok( ret, "unexpected failure %u\n", GetLastError() );
 473     ok( str != NULL, "str not set\n" );
 474     ok( !lstrcmpA( str, "@@BBEAAAAAAAAAAAAAAAAAAAAAAAAA" ), "got %s\n", str );
 475     pCredFree( str );
 476
 477     cert.rgbHashOfCert[0] = 1;
 478     cert.rgbHashOfCert[1] = 1;
 479     cert.rgbHashOfCert[2] = 1;
 480     str = NULL;
 481     ret = pCredMarshalCredentialA( CertCredential, &cert, &str );
 482     ok( ret, "unexpected failure %u\n", GetLastError() );
 483     ok( str != NULL, "str not set\n" );
 484     ok( !lstrcmpA( str, "@@BBEQAAAAAAAAAAAAAAAAAAAAAAAA" ), "got %s\n", str );
 485     pCredFree( str );
 486
 487     memset( cert.rgbHashOfCert, 0, sizeof(cert.rgbHashOfCert) );
 488     cert.rgbHashOfCert[0] = 'W';
 489     cert.rgbHashOfCert[1] = 'i';
 490     cert.rgbHashOfCert[2] = 'n';
 491     cert.rgbHashOfCert[3] = 'e';
 492     str = NULL;
 493     ret = pCredMarshalCredentialA( CertCredential, &cert, &str );
 494     ok( ret, "unexpected failure %u\n", GetLastError() );
 495     ok( str != NULL, "str not set\n" );
 496     ok( !lstrcmpA( str, "@@BXlmblBAAAAAAAAAAAAAAAAAAAAA" ), "got %s\n", str );
 497     pCredFree( str );
 498
 499     memset( cert.rgbHashOfCert, 0xff, sizeof(cert.rgbHashOfCert) );
 500     str = NULL;
 501     ret = pCredMarshalCredentialA( CertCredential, &cert, &str );
 502     ok( ret, "unexpected failure %u\n", GetLastError() );
 503     ok( str != NULL, "str not set\n" );
 504     ok( !lstrcmpA( str, "@@B--------------------------P" ), "got %s\n", str );
 505     pCredFree( str );
 506
 507     username.UserName = NULL;
 508     str = (char *)0xdeadbeef;
 509     SetLastError( 0xdeadbeef );
 510     ret = pCredMarshalCredentialA( UsernameTargetCredential, &username, &str );
 511     error = GetLastError();
 512     ok( !ret, "unexpected success\n" );
 513     ok( error == ERROR_INVALID_PARAMETER, "got %u\n", error );
 514     ok( str == (char *)0xdeadbeef, "got %p\n", str );
 515
 516     username.UserName = emptyW;
 517     str = (char *)0xdeadbeef;
 518     SetLastError( 0xdeadbeef );
 519     ret = pCredMarshalCredentialA( UsernameTargetCredential, &username, &str );
 520     error = GetLastError();
 521     ok( !ret, "unexpected success\n" );
 522     ok( error == ERROR_INVALID_PARAMETER, "got %u\n", error );
 523     ok( str == (char *)0xdeadbeef, "got %p\n", str );
 524
 525     username.UserName = tW;
 526     str = NULL;
 527     ret = pCredMarshalCredentialA( UsernameTargetCredential, &username, &str );
 528     ok( ret, "unexpected failure %u\n", GetLastError() );
 529     ok( str != NULL, "str not set\n" );
 530     ok( !lstrcmpA( str, "@@CCAAAAA0BA" ), "got %s\n", str );
 531     pCredFree( str );
 532
 533     username.UserName = teW;
 534     str = NULL;
 535     ret = pCredMarshalCredentialA( UsernameTargetCredential, &username, &str );
 536     ok( ret, "unexpected failure %u\n", GetLastError() );
 537     ok( str != NULL, "str not set\n" );
 538     ok( !lstrcmpA( str, "@@CEAAAAA0BQZAA" ), "got %s\n", str );
 539     pCredFree( str );
 540
 541     username.UserName = tesW;
 542     str = NULL;
 543     ret = pCredMarshalCredentialA( UsernameTargetCredential, &username, &str );
 544     ok( ret, "unexpected failure %u\n", GetLastError() );
 545     ok( str != NULL, "str not set\n" );
 546     ok( !lstrcmpA( str, "@@CGAAAAA0BQZAMHA" ), "got %s\n", str );
 547     pCredFree( str );
 548
 549     username.UserName = testW;
 550     str = NULL;
 551     ret = pCredMarshalCredentialA( UsernameTargetCredential, &username, &str );
 552     ok( ret, "unexpected failure %u\n", GetLastError() );
 553     ok( str != NULL, "str not set\n" );
 554     ok( !lstrcmpA( str, "@@CIAAAAA0BQZAMHA0BA" ), "got %s\n", str );
 555     pCredFree( str );
 556
 557     username.UserName = test1W;
 558     str = NULL;
 559     ret = pCredMarshalCredentialA( UsernameTargetCredential, &username, &str );
 560     ok( ret, "unexpected failure %u\n", GetLastError() );
 561     ok( str != NULL, "str not set\n" );
 562     ok( !lstrcmpA( str, "@@CKAAAAA0BQZAMHA0BQMAA" ), "got %s\n", str );
 563     pCredFree( str );
 564 }
 565
 566 static void test_CredUnmarshalCredentialA(void)
 567 {
 568     static const UCHAR cert_empty[CERT_HASH_LENGTH] = {0};
 569     static const UCHAR cert_wine[CERT_HASH_LENGTH] = {'W','i','n','e',0};
 570     static const WCHAR tW[] = {'t',0};
 571     static const WCHAR teW[] = {'t','e',0};
 572     static const WCHAR tesW[] = {'t','e','s',0};
 573     static const WCHAR testW[] = {'t','e','s','t',0};
 574     void *p;
 575     CERT_CREDENTIAL_INFO *cert;
 576     const UCHAR *hash;
 577     USERNAME_TARGET_CREDENTIAL_INFO *username;
 578     CRED_MARSHAL_TYPE type;
 579     unsigned int i, j;
 580     DWORD error;
 581     BOOL ret;
 582     const struct {
 583         const char *cred;
 584         CRED_MARSHAL_TYPE type;
 585         const void *unmarshaled;
 586     } tests[] = {
 587         { "", 0, NULL },
 588         { "@", 0, NULL },
 589         { "@@", 0, NULL },
 590         { "@@@", 0, NULL },
 591         { "@@A", 0, NULL },
 592         { "@@E", 4, NULL },
 593         { "@@Z", 25, NULL },
 594         { "@@a", 26, NULL },
 595         { "@@0", 52, NULL },
 596         { "@@#", 62, NULL },
 597         { "@@-", 63, NULL },
 598         { "@@B", CertCredential, NULL },
 599         { "@@BA", CertCredential, NULL },
 600         { "@@BAAAAAAAAAAAAAAAAAAAAAAAAAA", CertCredential, NULL },
 601         { "@@BAAAAAAAAAAAAAAAAAAAAAAAAAAAA", CertCredential, NULL },
 602         { "@@BAAAAAAAAAAAAAAAAAAAAAAAAAAA", CertCredential, cert_empty },
 603         { "@@BXlmblBAAAAAAAAAAAAAAAAAAAAA", CertCredential, cert_wine },
 604         { "@@C", UsernameTargetCredential, NULL },
 605         { "@@CA", UsernameTargetCredential, NULL },
 606         { "@@CAAAAAA", UsernameTargetCredential, NULL },
 607         { "@@CAAAAAA0B", UsernameTargetCredential, NULL },
 608         { "@@CAAAAAA0BA", UsernameTargetCredential, NULL },
 609         { "@@CCAAAAA0BA", UsernameTargetCredential, tW },
 610         { "@@CEAAAAA0BA", UsernameTargetCredential, NULL },
 611         { "@@CEAAAAA0BAd", UsernameTargetCredential, NULL },
 612         { "@@CEAAAAA0BAdA", UsernameTargetCredential, NULL },
 613         { "@@CEAAAAA0BQZAA", UsernameTargetCredential, teW },
 614         { "@@CEAAAAA0BQZAQ", UsernameTargetCredential, teW },
 615         { "@@CEAAAAA0BQZAg", UsernameTargetCredential, teW },
 616         { "@@CEAAAAA0BQZAw", UsernameTargetCredential, teW },
 617         { "@@CEAAAAA0BQZAAA", UsernameTargetCredential, NULL },
 618         { "@@CGAAAAA0BQZAMH", UsernameTargetCredential, NULL },
 619         { "@@CGAAAAA0BQZAMHA", UsernameTargetCredential, tesW },
 620         { "@@CGAAAAA0BQZAMHAA", UsernameTargetCredential, NULL },
 621         { "@@CCAAAAA0BAA", UsernameTargetCredential, NULL },
 622         { "@@CBAAAAA0BAA", UsernameTargetCredential, NULL },
 623         { "@@CAgAAAA0BAA", UsernameTargetCredential, NULL },
 624         { "@@CIAAAAA0BQZAMHA0BA", UsernameTargetCredential, testW },
 625         { "@@CA-----0BQZAMHA0BA", UsernameTargetCredential, NULL },
 626     };
 627
 628     SetLastError( 0xdeadbeef );
 629     ret = pCredUnmarshalCredentialA( NULL, NULL, NULL );
 630     error = GetLastError();
 631     ok( !ret, "unexpected success\n" );
 632     ok( error == ERROR_INVALID_PARAMETER, "got %u\n", error );
 633
 634     cert = NULL;
 635     SetLastError( 0xdeadbeef );
 636     ret = pCredUnmarshalCredentialA( NULL, NULL, (void **)&cert );
 637     error = GetLastError();
 638     ok( !ret, "unexpected success\n" );
 639     ok( error == ERROR_INVALID_PARAMETER, "got %u\n", error );
 640
 641     type = 0;
 642     cert = NULL;
 643     SetLastError( 0xdeadbeef );
 644     ret = pCredUnmarshalCredentialA( NULL, &type, (void **)&cert );
 645     error = GetLastError();
 646     ok( !ret, "unexpected success\n" );
 647     ok( error == ERROR_INVALID_PARAMETER, "got %u\n", error );
 648
 649     if (0) { /* crash */
 650     SetLastError( 0xdeadbeef );
 651     ret = pCredUnmarshalCredentialA( "@@BAAAAAAAAAAAAAAAAAAAAAAAAAAA", &type, NULL );
 652     error = GetLastError();
 653     ok( !ret, "unexpected success\n" );
 654     ok( error == ERROR_INVALID_PARAMETER, "got %u\n", error );
 655
 656     SetLastError( 0xdeadbeef );
 657     ret = pCredUnmarshalCredentialA( "@@BAAAAAAAAAAAAAAAAAAAAAAAAAAA", NULL, (void **)&cert );
 658     error = GetLastError();
 659     ok( !ret, "unexpected success\n" );
 660     ok( error == ERROR_INVALID_PARAMETER, "got %u\n", error );
 661     }
 662
 663     for (i = 0; i < ARRAY_SIZE(tests); i++)
 664     {
 665         SetLastError(0xdeadbeef);
 666         type = 0;
 667         p = NULL;
 668         ret = pCredUnmarshalCredentialA(tests[i].cred, &type, &p);
 669         error = GetLastError();
 670         if (tests[i].unmarshaled)
 671         {
 672             ok(ret, "[%u] unexpected failure %u\n", i, error);
 673             ok(type == tests[i].type, "[%u] got %u\n", i, type);
 674             ok(p != NULL, "[%u] returned pointer is NULL\n", i);
 675             if (tests[i].type == CertCredential)
 676             {
 677                 cert = p;
 678                 hash = tests[i].unmarshaled;
 679                 ok(cert->cbSize == sizeof(*cert),
 680                    "[%u] wrong size %u\n", i, cert->cbSize);
 681                 for (j = 0; j < sizeof(cert->rgbHashOfCert); j++)
 682                     ok(cert->rgbHashOfCert[j] == hash[j], "[%u] wrong data\n", i);
 683             }
 684             else if (tests[i].type == UsernameTargetCredential)
 685             {
 686                 username = p;
 687                 ok(username->UserName != NULL, "[%u] UserName is NULL\n", i);
 688                 ok(!lstrcmpW(username->UserName, tests[i].unmarshaled),
 689                    "[%u] got %s\n", i, wine_dbgstr_w(username->UserName));
 690             }
 691         }
 692         else
 693         {
 694             ok(!ret, "[%u] unexpected success\n", i);
 695             ok(error == ERROR_INVALID_PARAMETER, "[%u] got %u\n", i, error);
 696             ok(type == tests[i].type, "[%u] got %u\n", i, type);
 697             ok(p == NULL, "[%u] returned pointer is not NULL\n", i);
 698         }
 699
 700         if (ret)
 701             pCredFree(p);
 702     }
 703 }
 704
 705 static void test_CredIsMarshaledCredentialA(void)
 706 {
 707     int i;
 708     BOOL res;
 709     BOOL expected = TRUE;
 710
 711     const char * ptr[] = {
 712         /* CertCredential */
 713         "@@BXlmblBAAAAAAAAAAAAAAAAAAAAA",   /* hash for 'W','i','n','e' */
 714         "@@BAAAAAAAAAAAAAAAAAAAAAAAAAAA",   /* hash for all 0 */
 715
 716         /* UsernameTargetCredential */
 717         "@@CCAAAAA0BA",                     /* "t" */
 718         "@@CIAAAAA0BQZAMHA0BA",             /* "test" */
 719
 720         /* todo: BinaryBlobCredential */
 721
 722         /* not marshaled names return always FALSE */
 723         "winetest",
 724         "",
 725         "@@",
 726         "@@A",
 727         "@@AA",
 728         "@@AAA",
 729         "@@B",
 730         "@@BB",
 731         "@@BBB",
 732
 733         /* CertCredential */
 734         "@@BAAAAAAAAAAAAAAAAAAAAAAAAAAAA",  /* to long */
 735         "@@BAAAAAAAAAAAAAAAAAAAAAAAAAA",    /* to short */
 736         "@@BAAAAAAAAAAAAAAAAAAAAAAAAAA+",   /* bad char */
 737         "@@BAAAAAAAAAAAAAAAAAAAAAAAAAA:",
 738         "@@BAAAAAAAAAAAAAAAAAAAAAAAAAA>",
 739         "@@BAAAAAAAAAAAAAAAAAAAAAAAAAA<",
 740
 741         "@@C",
 742         "@@CC",
 743         "@@CCC",
 744         "@@D",
 745         "@@DD",
 746         "@@DDD",
 747         NULL};
 748
 749     for (i = 0; ptr[i]; i++)
 750     {
 751         if (*ptr[i] != '@')
 752             expected = FALSE;
 753
 754         SetLastError(0xdeadbeef);
 755         res = pCredIsMarshaledCredentialA(ptr[i]);
 756         if (expected)
 757             ok(res != FALSE, "%d: got %d and %u for %s (expected TRUE)\n", i, res, GetLastError(), ptr[i]);
 758         else
 759         {
 760             /* Windows returns ERROR_INVALID_PARAMETER here, but that's not documented */
 761             ok(!res, "%d: got %d and %u for %s (expected FALSE)\n", i, res, GetLastError(), ptr[i]);
 762         }
 763     }
 764 }
 765
 766 START_TEST(cred)
 767 {
 768     DWORD persists[CRED_TYPE_MAXIMUM];
 769     HMODULE mod = GetModuleHandleA("advapi32.dll");
 770
 771     pCredEnumerateA = (void *)GetProcAddress(mod, "CredEnumerateA");
 772     pCredFree = (void *)GetProcAddress(mod, "CredFree");
 773     pCredGetSessionTypes = (void *)GetProcAddress(mod, "CredGetSessionTypes");
 774     pCredWriteA = (void *)GetProcAddress(mod, "CredWriteA");
 775     pCredDeleteA = (void *)GetProcAddress(mod, "CredDeleteA");
 776     pCredReadA = (void *)GetProcAddress(mod, "CredReadA");
 777     pCredRenameA = (void *)GetProcAddress(mod, "CredRenameA");
 778     pCredReadDomainCredentialsA = (void *)GetProcAddress(mod, "CredReadDomainCredentialsA");
 779     pCredMarshalCredentialA = (void *)GetProcAddress(mod, "CredMarshalCredentialA");
 780     pCredUnmarshalCredentialA = (void *)GetProcAddress(mod, "CredUnmarshalCredentialA");
 781     pCredIsMarshaledCredentialA = (void *)GetProcAddress(mod, "CredIsMarshaledCredentialA");
 782
 783     if (!pCredEnumerateA || !pCredFree || !pCredWriteA || !pCredDeleteA || !pCredReadA)
 784     {
 785         win_skip("credentials functions not present in advapi32.dll\n");
 786         return;
 787     }
 788
 789     if (pCredGetSessionTypes)
 790     {
 791         BOOL ret;
 792         DWORD i;
 793         ret = pCredGetSessionTypes(CRED_TYPE_MAXIMUM, persists);
 794         ok(ret, "CredGetSessionTypes failed with error %d\n", GetLastError());
 795         ok(persists[0] == CRED_PERSIST_NONE, "persists[0] = %u instead of CRED_PERSIST_NONE\n", persists[0]);
 796         for (i=0; i < CRED_TYPE_MAXIMUM; i++)
 797             ok(persists[i] <= CRED_PERSIST_ENTERPRISE, "bad value for persists[%u]: %u\n", i, persists[i]);
 798     }
 799     else
 800         memset(persists, CRED_PERSIST_ENTERPRISE, sizeof(persists));
 801
 802     test_CredReadA();
 803     test_CredWriteA();
 804     test_CredDeleteA();
 805
 806     test_CredReadDomainCredentialsA();
 807
 808     trace("generic:\n");
 809     if (persists[CRED_TYPE_GENERIC] == CRED_PERSIST_NONE)
 810         skip("CRED_TYPE_GENERIC credentials are not supported or are disabled. Skipping\n");
 811     else
 812         test_generic();
 813
 814         trace("domain password:\n");
 815     if (persists[CRED_TYPE_DOMAIN_PASSWORD] == CRED_PERSIST_NONE)
 816         skip("CRED_TYPE_DOMAIN_PASSWORD credentials are not supported or are disabled. Skipping\n");
 817     else
 818         test_domain_password(CRED_TYPE_DOMAIN_PASSWORD);
 819
 820     trace("domain visible password:\n");
 821     if (persists[CRED_TYPE_DOMAIN_VISIBLE_PASSWORD] == CRED_PERSIST_NONE)
 822         skip("CRED_TYPE_DOMAIN_VISIBLE_PASSWORD credentials are not supported or are disabled. Skipping\n");
 823     else
 824         test_domain_password(CRED_TYPE_DOMAIN_VISIBLE_PASSWORD);
 825
 826     test_CredMarshalCredentialA();
 827     test_CredUnmarshalCredentialA();
 828     test_CredIsMarshaledCredentialA();
 829 }