dlls/crypt32/str.c

   1 /*
   2  * Copyright 2006 Juan Lang for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18 #include <stdarg.h>
  19 #include "windef.h"
  20 #include "winbase.h"
  21 #include "winnls.h"
  22 #include "winuser.h"
  23 #include "wincrypt.h"
  24 #include "wine/debug.h"
  25 #include "wine/unicode.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
  28
  29 DWORD WINAPI CertRDNValueToStrA(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
  30  LPSTR psz, DWORD csz)
  31 {
  32     DWORD ret = 0;
  33
  34     TRACE("(%d, %p, %p, %d)\n", dwValueType, pValue, psz, csz);
  35
  36     switch (dwValueType)
  37     {
  38     case CERT_RDN_ANY_TYPE:
  39         break;
  40     case CERT_RDN_NUMERIC_STRING:
  41     case CERT_RDN_PRINTABLE_STRING:
  42     case CERT_RDN_TELETEX_STRING:
  43     case CERT_RDN_VIDEOTEX_STRING:
  44     case CERT_RDN_IA5_STRING:
  45     case CERT_RDN_GRAPHIC_STRING:
  46     case CERT_RDN_VISIBLE_STRING:
  47     case CERT_RDN_GENERAL_STRING:
  48         if (!psz || !csz)
  49             ret = pValue->cbData;
  50         else
  51         {
  52             DWORD chars = min(pValue->cbData, csz - 1);
  53
  54             if (chars)
  55             {
  56                 memcpy(psz, pValue->pbData, chars);
  57                 ret += chars;
  58                 csz -= chars;
  59             }
  60         }
  61         break;
  62     default:
  63         FIXME("string type %d unimplemented\n", dwValueType);
  64     }
  65     if (psz && csz)
  66     {
  67         *(psz + ret) = '\0';
  68         csz--;
  69         ret++;
  70     }
  71     else
  72         ret++;
  73     TRACE("returning %d (%s)\n", ret, debugstr_a(psz));
  74     return ret;
  75 }
  76
  77 DWORD WINAPI CertRDNValueToStrW(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
  78  LPWSTR psz, DWORD csz)
  79 {
  80     DWORD ret = 0;
  81
  82     TRACE("(%d, %p, %p, %d)\n", dwValueType, pValue, psz, csz);
  83
  84     switch (dwValueType)
  85     {
  86     case CERT_RDN_ANY_TYPE:
  87         break;
  88     case CERT_RDN_NUMERIC_STRING:
  89     case CERT_RDN_PRINTABLE_STRING:
  90     case CERT_RDN_TELETEX_STRING:
  91     case CERT_RDN_VIDEOTEX_STRING:
  92     case CERT_RDN_IA5_STRING:
  93     case CERT_RDN_GRAPHIC_STRING:
  94     case CERT_RDN_VISIBLE_STRING:
  95     case CERT_RDN_GENERAL_STRING:
  96         if (!psz || !csz)
  97             ret = pValue->cbData;
  98         else
  99         {
 100             DWORD chars = min(pValue->cbData, csz - 1);
 101
 102             if (chars)
 103             {
 104                 DWORD i;
 105
 106                 for (i = 0; i < chars; i++)
 107                     psz[i] = pValue->pbData[i];
 108                 ret += chars;
 109                 csz -= chars;
 110             }
 111         }
 112         break;
 113     default:
 114         FIXME("string type %d unimplemented\n", dwValueType);
 115     }
 116     if (psz && csz)
 117     {
 118         *(psz + ret) = '\0';
 119         csz--;
 120         ret++;
 121     }
 122     else
 123         ret++;
 124     TRACE("returning %d (%s)\n", ret, debugstr_w(psz));
 125     return ret;
 126 }
 127
 128 /* Adds the prefix prefix to the string pointed to by psz, followed by the
 129  * character '='.  Copies no more than csz characters.  Returns the number of
 130  * characters copied.  If psz is NULL, returns the number of characters that
 131  * would be copied.
 132  */
 133 static DWORD CRYPT_AddPrefixA(LPCSTR prefix, LPSTR psz, DWORD csz)
 134 {
 135     DWORD chars;
 136
 137     TRACE("(%s, %p, %d)\n", debugstr_a(prefix), psz, csz);
 138
 139     if (psz)
 140     {
 141         chars = min(lstrlenA(prefix), csz);
 142         memcpy(psz, prefix, chars);
 143         csz -= chars;
 144         *(psz + chars) = '=';
 145         chars++;
 146         csz--;
 147     }
 148     else
 149         chars = lstrlenA(prefix) + 1;
 150     return chars;
 151 }
 152
 153 DWORD WINAPI CertNameToStrA(DWORD dwCertEncodingType, PCERT_NAME_BLOB pName,
 154  DWORD dwStrType, LPSTR psz, DWORD csz)
 155 {
 156     static const DWORD unsupportedFlags = CERT_NAME_STR_NO_QUOTING_FLAG |
 157      CERT_NAME_STR_REVERSE_FLAG | CERT_NAME_STR_ENABLE_T61_UNICODE_FLAG;
 158     static const char commaSep[] = ", ";
 159     static const char semiSep[] = "; ";
 160     static const char crlfSep[] = "\r\n";
 161     static const char plusSep[] = " + ";
 162     static const char spaceSep[] = " ";
 163     DWORD ret = 0, bytes = 0;
 164     BOOL bRet;
 165     CERT_NAME_INFO *info;
 166
 167     TRACE("(%d, %p, %08x, %p, %d)\n", dwCertEncodingType, pName, dwStrType,
 168      psz, csz);
 169     if (dwStrType & unsupportedFlags)
 170         FIXME("unsupported flags: %08x\n", dwStrType & unsupportedFlags);
 171
 172     bRet = CryptDecodeObjectEx(dwCertEncodingType, X509_NAME, pName->pbData,
 173      pName->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &bytes);
 174     if (bRet)
 175     {
 176         DWORD i, j, sepLen, rdnSepLen;
 177         LPCSTR sep, rdnSep;
 178
 179         if (dwStrType & CERT_NAME_STR_SEMICOLON_FLAG)
 180             sep = semiSep;
 181         else if (dwStrType & CERT_NAME_STR_CRLF_FLAG)
 182             sep = crlfSep;
 183         else
 184             sep = commaSep;
 185         sepLen = strlen(sep);
 186         if (dwStrType & CERT_NAME_STR_NO_PLUS_FLAG)
 187             rdnSep = spaceSep;
 188         else
 189             rdnSep = plusSep;
 190         rdnSepLen = strlen(rdnSep);
 191         for (i = 0; (!psz || ret < csz) && i < info->cRDN; i++)
 192         {
 193             for (j = 0; (!psz || ret < csz) && j < info->rgRDN[i].cRDNAttr; j++)
 194             {
 195                 DWORD chars;
 196                 char prefixBuf[10]; /* big enough for GivenName */
 197                 LPCSTR prefix = NULL;
 198
 199                 if ((dwStrType & 0x000000ff) == CERT_OID_NAME_STR)
 200                     prefix = info->rgRDN[i].rgRDNAttr[j].pszObjId;
 201                 else if ((dwStrType & 0x000000ff) == CERT_X500_NAME_STR)
 202                 {
 203                     PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(
 204                      CRYPT_OID_INFO_OID_KEY,
 205                      info->rgRDN[i].rgRDNAttr[j].pszObjId,
 206                      CRYPT_RDN_ATTR_OID_GROUP_ID);
 207
 208                     if (oidInfo)
 209                     {
 210                         WideCharToMultiByte(CP_ACP, 0, oidInfo->pwszName, -1,
 211                          prefixBuf, sizeof(prefixBuf), NULL, NULL);
 212                         prefix = prefixBuf;
 213                     }
 214                     else
 215                         prefix = info->rgRDN[i].rgRDNAttr[j].pszObjId;
 216                 }
 217                 if (prefix)
 218                 {
 219                     /* - 1 is needed to account for the NULL terminator. */
 220                     chars = CRYPT_AddPrefixA(prefix,
 221                      psz ? psz + ret : NULL, psz ? csz - ret - 1 : 0);
 222                     ret += chars;
 223                     csz -= chars;
 224                 }
 225                 /* FIXME: handle quoting */
 226                 chars = CertRDNValueToStrA(
 227                  info->rgRDN[i].rgRDNAttr[j].dwValueType,
 228                  &info->rgRDN[i].rgRDNAttr[j].Value, psz ? psz + ret : NULL,
 229                  psz ? csz - ret : 0);
 230                 if (chars)
 231                     ret += chars - 1;
 232                 if (j < info->rgRDN[i].cRDNAttr - 1)
 233                 {
 234                     if (psz && ret < csz - rdnSepLen - 1)
 235                         memcpy(psz + ret, rdnSep, rdnSepLen);
 236                     ret += rdnSepLen;
 237                 }
 238             }
 239             if (i < info->cRDN - 1)
 240             {
 241                 if (psz && ret < csz - sepLen - 1)
 242                     memcpy(psz + ret, sep, sepLen);
 243                 ret += sepLen;
 244             }
 245         }
 246         LocalFree(info);
 247     }
 248     if (psz && csz)
 249     {
 250         *(psz + ret) = '\0';
 251         csz--;
 252         ret++;
 253     }
 254     else
 255         ret++;
 256     TRACE("Returning %s\n", debugstr_a(psz));
 257     return ret;
 258 }
 259
 260 /* Adds the prefix prefix to the wide-character string pointed to by psz,
 261  * followed by the character '='.  Copies no more than csz characters.  Returns
 262  * the number of characters copied.  If psz is NULL, returns the number of
 263  * characters that would be copied.
 264  * Assumes the characters in prefix are ASCII (not multibyte characters.)
 265  */
 266 static DWORD CRYPT_AddPrefixAToW(LPCSTR prefix, LPWSTR psz, DWORD csz)
 267 {
 268     DWORD chars;
 269
 270     TRACE("(%s, %p, %d)\n", debugstr_a(prefix), psz, csz);
 271
 272     if (psz)
 273     {
 274         DWORD i;
 275
 276         chars = min(lstrlenA(prefix), csz);
 277         for (i = 0; i < chars; i++)
 278             *(psz + i) = prefix[i];
 279         csz -= chars;
 280         *(psz + chars) = '=';
 281         chars++;
 282         csz--;
 283     }
 284     else
 285         chars = lstrlenA(prefix) + 1;
 286     return chars;
 287 }
 288
 289 /* Adds the prefix prefix to the string pointed to by psz, followed by the
 290  * character '='.  Copies no more than csz characters.  Returns the number of
 291  * characters copied.  If psz is NULL, returns the number of characters that
 292  * would be copied.
 293  */
 294 static DWORD CRYPT_AddPrefixW(LPCWSTR prefix, LPWSTR psz, DWORD csz)
 295 {
 296     DWORD chars;
 297
 298     TRACE("(%s, %p, %d)\n", debugstr_w(prefix), psz, csz);
 299
 300     if (psz)
 301     {
 302         chars = min(lstrlenW(prefix), csz);
 303         memcpy(psz, prefix, chars * sizeof(WCHAR));
 304         csz -= chars;
 305         *(psz + chars) = '=';
 306         chars++;
 307         csz--;
 308     }
 309     else
 310         chars = lstrlenW(prefix) + 1;
 311     return chars;
 312 }
 313
 314 DWORD WINAPI CertNameToStrW(DWORD dwCertEncodingType, PCERT_NAME_BLOB pName,
 315  DWORD dwStrType, LPWSTR psz, DWORD csz)
 316 {
 317     static const DWORD unsupportedFlags = CERT_NAME_STR_NO_QUOTING_FLAG |
 318      CERT_NAME_STR_REVERSE_FLAG | CERT_NAME_STR_ENABLE_T61_UNICODE_FLAG;
 319     static const WCHAR commaSep[] = { ',',' ',0 };
 320     static const WCHAR semiSep[] = { ';',' ',0 };
 321     static const WCHAR crlfSep[] = { '\r','\n',0 };
 322     static const WCHAR plusSep[] = { ' ','+',' ',0 };
 323     static const WCHAR spaceSep[] = { ' ',0 };
 324     DWORD ret = 0, bytes = 0;
 325     BOOL bRet;
 326     CERT_NAME_INFO *info;
 327
 328     TRACE("(%d, %p, %08x, %p, %d)\n", dwCertEncodingType, pName, dwStrType,
 329      psz, csz);
 330     if (dwStrType & unsupportedFlags)
 331         FIXME("unsupported flags: %08x\n", dwStrType & unsupportedFlags);
 332
 333     bRet = CryptDecodeObjectEx(dwCertEncodingType, X509_NAME, pName->pbData,
 334      pName->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &bytes);
 335     if (bRet)
 336     {
 337         DWORD i, j, sepLen, rdnSepLen;
 338         LPCWSTR sep, rdnSep;
 339
 340         if (dwStrType & CERT_NAME_STR_SEMICOLON_FLAG)
 341             sep = semiSep;
 342         else if (dwStrType & CERT_NAME_STR_CRLF_FLAG)
 343             sep = crlfSep;
 344         else
 345             sep = commaSep;
 346         sepLen = lstrlenW(sep);
 347         if (dwStrType & CERT_NAME_STR_NO_PLUS_FLAG)
 348             rdnSep = spaceSep;
 349         else
 350             rdnSep = plusSep;
 351         rdnSepLen = lstrlenW(rdnSep);
 352         for (i = 0; (!psz || ret < csz) && i < info->cRDN; i++)
 353         {
 354             for (j = 0; (!psz || ret < csz) && j < info->rgRDN[i].cRDNAttr; j++)
 355             {
 356                 DWORD chars;
 357                 LPCSTR prefixA = NULL;
 358                 LPCWSTR prefixW = NULL;
 359
 360                 if ((dwStrType & 0x000000ff) == CERT_OID_NAME_STR)
 361                     prefixA = info->rgRDN[i].rgRDNAttr[j].pszObjId;
 362                 else if ((dwStrType & 0x000000ff) == CERT_X500_NAME_STR)
 363                 {
 364                     PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(
 365                      CRYPT_OID_INFO_OID_KEY,
 366                      info->rgRDN[i].rgRDNAttr[j].pszObjId,
 367                      CRYPT_RDN_ATTR_OID_GROUP_ID);
 368
 369                     if (oidInfo)
 370                         prefixW = oidInfo->pwszName;
 371                     else
 372                         prefixA = info->rgRDN[i].rgRDNAttr[j].pszObjId;
 373                 }
 374                 if (prefixW)
 375                 {
 376                     /* - 1 is needed to account for the NULL terminator. */
 377                     chars = CRYPT_AddPrefixW(prefixW,
 378                      psz ? psz + ret : NULL, psz ? csz - ret - 1 : 0);
 379                     ret += chars;
 380                     csz -= chars;
 381                 }
 382                 else if (prefixA)
 383                 {
 384                     /* - 1 is needed to account for the NULL terminator. */
 385                     chars = CRYPT_AddPrefixAToW(prefixA,
 386                      psz ? psz + ret : NULL, psz ? csz - ret - 1 : 0);
 387                     ret += chars;
 388                     csz -= chars;
 389                 }
 390                 /* FIXME: handle quoting */
 391                 chars = CertRDNValueToStrW(
 392                  info->rgRDN[i].rgRDNAttr[j].dwValueType,
 393                  &info->rgRDN[i].rgRDNAttr[j].Value, psz ? psz + ret : NULL,
 394                  psz ? csz - ret : 0);
 395                 if (chars)
 396                     ret += chars - 1;
 397                 if (j < info->rgRDN[i].cRDNAttr - 1)
 398                 {
 399                     if (psz && ret < csz - rdnSepLen - 1)
 400                         memcpy(psz + ret, rdnSep, rdnSepLen * sizeof(WCHAR));
 401                     ret += rdnSepLen;
 402                 }
 403             }
 404             if (i < info->cRDN - 1)
 405             {
 406                 if (psz && ret < csz - sepLen - 1)
 407                     memcpy(psz + ret, sep, sepLen * sizeof(WCHAR));
 408                 ret += sepLen;
 409             }
 410         }
 411         LocalFree(info);
 412     }
 413     if (psz && csz)
 414     {
 415         *(psz + ret) = '\0';
 416         csz--;
 417         ret++;
 418     }
 419     else
 420         ret++;
 421     TRACE("Returning %s\n", debugstr_w(psz));
 422     return ret;
 423 }
 424
 425 BOOL WINAPI CertStrToNameA(DWORD dwCertEncodingType, LPCSTR pszX500,
 426  DWORD dwStrType, void *pvReserved, BYTE *pbEncoded, DWORD *pcbEncoded,
 427  LPCSTR *ppszError)
 428 {
 429     LPWSTR x500, errorStr;
 430     BOOL ret;
 431     int len;
 432
 433     TRACE("(%08x, %s, %08x, %p, %p, %p, %p)\n", dwCertEncodingType,
 434      debugstr_a(pszX500), dwStrType, pvReserved, pbEncoded, pcbEncoded,
 435      ppszError);
 436
 437     len = MultiByteToWideChar(CP_ACP, 0, pszX500, -1, NULL, 0);
 438     x500 = CryptMemAlloc(len * sizeof(WCHAR));
 439     if (x500)
 440     {
 441         MultiByteToWideChar(CP_ACP, 0, pszX500, -1, x500, len);
 442         ret = CertStrToNameW(dwCertEncodingType, x500, dwStrType, pvReserved,
 443          pbEncoded, pcbEncoded, ppszError ? (LPCWSTR *)&errorStr : NULL);
 444         if (ppszError)
 445         {
 446             DWORD i;
 447
 448             *ppszError = pszX500;
 449             for (i = 0; i < errorStr - x500; i++)
 450                 *ppszError = CharNextA(*ppszError);
 451         }
 452         CryptMemFree(x500);
 453     }
 454     else
 455         ret = FALSE;
 456     return ret;
 457 }
 458
 459 struct KeynameKeeper
 460 {
 461     WCHAR  buf[10]; /* big enough for L"GivenName" */
 462     LPWSTR keyName; /* usually = buf, but may be allocated */
 463     DWORD  keyLen;
 464 };
 465
 466 static void CRYPT_InitializeKeynameKeeper(struct KeynameKeeper *keeper)
 467 {
 468     keeper->keyName = keeper->buf;
 469     keeper->keyLen = sizeof(keeper->buf) / sizeof(keeper->buf[0]);
 470 }
 471
 472 static void CRYPT_FreeKeynameKeeper(struct KeynameKeeper *keeper)
 473 {
 474     if (keeper->keyName != keeper->buf)
 475         CryptMemFree(keeper->keyName);
 476 }
 477
 478 struct X500TokenW
 479 {
 480     LPCWSTR start;
 481     LPCWSTR end;
 482 };
 483
 484 static void CRYPT_KeynameKeeperFromTokenW(struct KeynameKeeper *keeper,
 485  const struct X500TokenW *key)
 486 {
 487     DWORD len = key->end - key->start;
 488
 489     if (len > keeper->keyLen)
 490     {
 491         if (keeper->keyName == keeper->buf)
 492             keeper->keyName = CryptMemAlloc(len * sizeof(WCHAR));
 493         else
 494             keeper->keyName = CryptMemRealloc(keeper->keyName,
 495              len * sizeof(WCHAR));
 496         keeper->keyLen = len;
 497     }
 498     memcpy(keeper->keyName, key->start, (key->end - key->start) *
 499      sizeof(WCHAR));
 500     keeper->keyName[len] = '\0';
 501     TRACE("Keyname is %s\n", debugstr_w(keeper->keyName));
 502 }
 503
 504 static DWORD CRYPT_GetNextKeyW(LPCWSTR str, struct X500TokenW *token,
 505  LPCWSTR *ppszError)
 506 {
 507     DWORD ret = ERROR_SUCCESS;
 508
 509     while (*str && isspaceW(*str))
 510         str++;
 511     if (*str)
 512     {
 513         token->start = str;
 514         while (*str && *str != '=' && !isspaceW(*str))
 515             str++;
 516         if (*str && (*str == '=' || isspaceW(*str)))
 517             token->end = str;
 518         else
 519         {
 520             TRACE("missing equals char at %s\n", debugstr_w(token->start));
 521             if (ppszError)
 522                 *ppszError = token->start;
 523             ret = CRYPT_E_INVALID_X500_STRING;
 524         }
 525     }
 526     else
 527         token->start = NULL;
 528     return ret;
 529 }
 530
 531 /* Assumes separators are characters in the 0-255 range */
 532 static DWORD CRYPT_GetNextValueW(LPCWSTR str, DWORD dwFlags, LPCWSTR separators,
 533  struct X500TokenW *token, LPCWSTR *ppszError)
 534 {
 535     DWORD ret = ERROR_SUCCESS;
 536
 537     TRACE("(%s, %s, %p, %p)\n", debugstr_w(str), debugstr_w(separators), token,
 538      ppszError);
 539
 540     while (*str && isspaceW(*str))
 541         str++;
 542     if (*str)
 543     {
 544         token->start = str;
 545         if (!(dwFlags & CERT_NAME_STR_NO_QUOTING_FLAG) && *str == '"')
 546         {
 547             token->end = NULL;
 548             str++;
 549             while (!token->end && !ret)
 550             {
 551                 while (*str && *str != '"')
 552                     str++;
 553                 if (*str == '"')
 554                 {
 555                     if (*(str + 1) != '"')
 556                         token->end = str + 1;
 557                     else
 558                         str += 2;
 559                 }
 560                 else
 561                 {
 562                     TRACE("unterminated quote at %s\n", debugstr_w(str));
 563                     if (ppszError)
 564                         *ppszError = str;
 565                     ret = CRYPT_E_INVALID_X500_STRING;
 566                 }
 567             }
 568         }
 569         else
 570         {
 571             WCHAR map[256] = { 0 };
 572
 573             while (*separators)
 574                 map[*separators++] = 1;
 575             while (*str && (*str >= 0xff || !map[*(const unsigned short *)str]))
 576                 str++;
 577             token->end = str;
 578         }
 579     }
 580     else
 581     {
 582         TRACE("missing value at %s\n", debugstr_w(str));
 583         if (ppszError)
 584             *ppszError = str;
 585         ret = CRYPT_E_INVALID_X500_STRING;
 586     }
 587     return ret;
 588 }
 589
 590 /* Encodes the string represented by value as the string type type into the
 591  * CERT_NAME_BLOB output.  If there is an error and ppszError is not NULL,
 592  * *ppszError is set to the first failing character.  If there is no error,
 593  * output's pbData must be freed with LocalFree.
 594  */
 595 static BOOL CRYPT_EncodeValueWithType(DWORD dwCertEncodingType,
 596  const struct X500TokenW *value, PCERT_NAME_BLOB output, DWORD type,
 597  LPCWSTR *ppszError)
 598 {
 599     CERT_NAME_VALUE nameValue = { type, { 0, NULL } };
 600     BOOL ret = FALSE;
 601
 602     nameValue.Value.pbData = CryptMemAlloc((value->end - value->start) *
 603      sizeof(WCHAR));
 604     if (nameValue.Value.pbData)
 605     {
 606         DWORD i;
 607         LPWSTR ptr = (LPWSTR)nameValue.Value.pbData;
 608
 609         for (i = 0; i < value->end - value->start; i++)
 610         {
 611             *ptr++ = value->start[i];
 612             if (value->start[i] == '"')
 613                 i++;
 614         }
 615         nameValue.Value.cbData = (LPBYTE)ptr - nameValue.Value.pbData;
 616         ret = CryptEncodeObjectEx(dwCertEncodingType, X509_UNICODE_NAME_VALUE,
 617          &nameValue, CRYPT_ENCODE_ALLOC_FLAG, NULL, &output->pbData,
 618          &output->cbData);
 619         if (!ret && ppszError)
 620         {
 621             if (type == CERT_RDN_NUMERIC_STRING &&
 622              GetLastError() == CRYPT_E_INVALID_NUMERIC_STRING)
 623                 *ppszError = value->start + output->cbData;
 624             else if (type == CERT_RDN_PRINTABLE_STRING &&
 625              GetLastError() == CRYPT_E_INVALID_PRINTABLE_STRING)
 626                 *ppszError = value->start + output->cbData;
 627             else if (type == CERT_RDN_IA5_STRING &&
 628              GetLastError() == CRYPT_E_INVALID_IA5_STRING)
 629                 *ppszError = value->start + output->cbData;
 630         }
 631         CryptMemFree(nameValue.Value.pbData);
 632     }
 633     return ret;
 634 }
 635
 636 static BOOL CRYPT_EncodeValue(DWORD dwCertEncodingType,
 637  const struct X500TokenW *value, PCERT_NAME_BLOB output, const DWORD *types,
 638  LPCWSTR *ppszError)
 639 {
 640     DWORD i;
 641     BOOL ret;
 642
 643     ret = FALSE;
 644     for (i = 0; !ret && types[i]; i++)
 645         ret = CRYPT_EncodeValueWithType(dwCertEncodingType, value, output,
 646          types[i], ppszError);
 647     return ret;
 648 }
 649
 650 static BOOL CRYPT_ValueToRDN(DWORD dwCertEncodingType, PCERT_NAME_INFO info,
 651  PCCRYPT_OID_INFO keyOID, struct X500TokenW *value, LPCWSTR *ppszError)
 652 {
 653     BOOL ret = FALSE;
 654
 655     TRACE("OID %s, value %s\n", debugstr_a(keyOID->pszOID),
 656      debugstr_wn(value->start, value->end - value->start));
 657
 658     if (!info->rgRDN)
 659         info->rgRDN = CryptMemAlloc(sizeof(CERT_RDN));
 660     else
 661         info->rgRDN = CryptMemRealloc(info->rgRDN,
 662          (info->cRDN + 1) * sizeof(CERT_RDN));
 663     if (info->rgRDN)
 664     {
 665         /* FIXME: support multiple RDN attrs */
 666         info->rgRDN[info->cRDN].rgRDNAttr =
 667          CryptMemAlloc(sizeof(CERT_RDN_ATTR));
 668         if (info->rgRDN[info->cRDN].rgRDNAttr)
 669         {
 670             static const DWORD defaultTypes[] = { CERT_RDN_PRINTABLE_STRING,
 671              CERT_RDN_BMP_STRING, 0 };
 672             const DWORD *types;
 673
 674             info->rgRDN[info->cRDN].cRDNAttr = 1;
 675             info->rgRDN[info->cRDN].rgRDNAttr[0].pszObjId =
 676              (LPSTR)keyOID->pszOID;
 677             info->rgRDN[info->cRDN].rgRDNAttr[0].dwValueType =
 678              CERT_RDN_ENCODED_BLOB;
 679             if (keyOID->ExtraInfo.cbData)
 680                 types = (const DWORD *)keyOID->ExtraInfo.pbData;
 681             else
 682                 types = defaultTypes;
 683
 684             /* Remove surrounding quotes */
 685             if (value->start[0] == '"')
 686             {
 687                 value->start++;
 688                 value->end--;
 689             }
 690             ret = CRYPT_EncodeValue(dwCertEncodingType, value,
 691              &info->rgRDN[info->cRDN].rgRDNAttr[0].Value, types, ppszError);
 692         }
 693     }
 694     if (ret)
 695         info->cRDN++;
 696     return ret;
 697 }
 698
 699 BOOL WINAPI CertStrToNameW(DWORD dwCertEncodingType, LPCWSTR pszX500,
 700  DWORD dwStrType, void *pvReserved, BYTE *pbEncoded, DWORD *pcbEncoded,
 701  LPCWSTR *ppszError)
 702 {
 703     CERT_NAME_INFO info = { 0, NULL };
 704     LPCWSTR str;
 705     struct KeynameKeeper keeper;
 706     DWORD i, error = ERROR_SUCCESS;
 707     BOOL ret = TRUE;
 708
 709     TRACE("(%08x, %s, %08x, %p, %p, %p, %p)\n", dwCertEncodingType,
 710      debugstr_w(pszX500), dwStrType, pvReserved, pbEncoded, pcbEncoded,
 711      ppszError);
 712
 713     CRYPT_InitializeKeynameKeeper(&keeper);
 714     str = pszX500;
 715     while (str && *str && !error && ret)
 716     {
 717         struct X500TokenW token;
 718
 719         error = CRYPT_GetNextKeyW(str, &token, ppszError);
 720         if (!error && token.start)
 721         {
 722             PCCRYPT_OID_INFO keyOID;
 723
 724             CRYPT_KeynameKeeperFromTokenW(&keeper, &token);
 725             keyOID = CryptFindOIDInfo(CRYPT_OID_INFO_NAME_KEY, keeper.keyName,
 726              CRYPT_RDN_ATTR_OID_GROUP_ID);
 727             if (!keyOID)
 728             {
 729                 if (ppszError)
 730                     *ppszError = token.start;
 731                 error = CRYPT_E_INVALID_X500_STRING;
 732             }
 733             else
 734             {
 735                 str = token.end;
 736                 while (isspace(*str))
 737                     str++;
 738                 if (*str != '=')
 739                 {
 740                     if (ppszError)
 741                         *ppszError = str;
 742                     error = CRYPT_E_INVALID_X500_STRING;
 743                 }
 744                 else
 745                 {
 746                     static const WCHAR commaSep[] = { ',',0 };
 747                     static const WCHAR semiSep[] = { ';',0 };
 748                     static const WCHAR crlfSep[] = { '\r','\n',0 };
 749                     static const WCHAR allSeps[] = { ',',';','\r','\n',0 };
 750                     LPCWSTR sep;
 751
 752                     str++;
 753                     if (dwStrType & CERT_NAME_STR_COMMA_FLAG)
 754                         sep = commaSep;
 755                     else if (dwStrType & CERT_NAME_STR_SEMICOLON_FLAG)
 756                         sep = semiSep;
 757                     else if (dwStrType & CERT_NAME_STR_CRLF_FLAG)
 758                         sep = crlfSep;
 759                     else
 760                         sep = allSeps;
 761                     error = CRYPT_GetNextValueW(str, dwStrType, sep, &token,
 762                      ppszError);
 763                     if (!error)
 764                     {
 765                         str = token.end;
 766                         ret = CRYPT_ValueToRDN(dwCertEncodingType, &info,
 767                          keyOID, &token, ppszError);
 768                     }
 769                 }
 770             }
 771         }
 772     }
 773     CRYPT_FreeKeynameKeeper(&keeper);
 774     if (!error)
 775     {
 776         ret = CryptEncodeObjectEx(dwCertEncodingType, X509_NAME, &info,
 777          0, NULL, pbEncoded, pcbEncoded);
 778         for (i = 0; i < info.cRDN; i++)
 779         {
 780             DWORD j;
 781
 782             for (j = 0; j < info.rgRDN[i].cRDNAttr; j++)
 783                 LocalFree(info.rgRDN[i].rgRDNAttr[j].Value.pbData);
 784             CryptMemFree(info.rgRDN[i].rgRDNAttr);
 785         }
 786         CryptMemFree(info.rgRDN);
 787     }
 788     else
 789     {
 790         SetLastError(error);
 791         ret = FALSE;
 792     }
 793     return ret;
 794 }
 795
 796 DWORD WINAPI CertGetNameStringA(PCCERT_CONTEXT pCertContext, DWORD dwType,
 797  DWORD dwFlags, void *pvTypePara, LPSTR pszNameString, DWORD cchNameString)
 798 {
 799     DWORD ret;
 800
 801     TRACE("(%p, %d, %08x, %p, %p, %d)\n", pCertContext, dwType, dwFlags,
 802      pvTypePara, pszNameString, cchNameString);
 803
 804     if (pszNameString)
 805     {
 806         LPWSTR wideName;
 807         DWORD nameLen;
 808
 809         nameLen = CertGetNameStringW(pCertContext, dwType, dwFlags, pvTypePara,
 810          NULL, 0);
 811         wideName = CryptMemAlloc(nameLen * sizeof(WCHAR));
 812         if (wideName)
 813         {
 814             CertGetNameStringW(pCertContext, dwType, dwFlags, pvTypePara,
 815              wideName, nameLen);
 816             nameLen = WideCharToMultiByte(CP_ACP, 0, wideName, nameLen,
 817              pszNameString, cchNameString, NULL, NULL);
 818             if (nameLen <= cchNameString)
 819                 ret = nameLen;
 820             else
 821             {
 822                 pszNameString[cchNameString - 1] = '\0';
 823                 ret = cchNameString;
 824             }
 825             CryptMemFree(wideName);
 826         }
 827         else
 828         {
 829             *pszNameString = '\0';
 830             ret = 1;
 831         }
 832     }
 833     else
 834         ret = CertGetNameStringW(pCertContext, dwType, dwFlags, pvTypePara,
 835          NULL, 0);
 836     return ret;
 837 }
 838
 839 DWORD WINAPI CertGetNameStringW(PCCERT_CONTEXT pCertContext, DWORD dwType,
 840  DWORD dwFlags, void *pvTypePara, LPWSTR pszNameString, DWORD cchNameString)
 841 {
 842     DWORD ret;
 843     PCERT_NAME_BLOB name;
 844     LPCSTR altNameOID;
 845
 846     TRACE("(%p, %d, %08x, %p, %p, %d)\n", pCertContext, dwType,
 847      dwFlags, pvTypePara, pszNameString, cchNameString);
 848
 849     if (dwFlags & CERT_NAME_ISSUER_FLAG)
 850     {
 851         name = &pCertContext->pCertInfo->Issuer;
 852         altNameOID = szOID_ISSUER_ALT_NAME;
 853     }
 854     else
 855     {
 856         name = &pCertContext->pCertInfo->Subject;
 857         altNameOID = szOID_SUBJECT_ALT_NAME;
 858     }
 859
 860     switch (dwType)
 861     {
 862     case CERT_NAME_SIMPLE_DISPLAY_TYPE:
 863     {
 864         static const LPCSTR simpleAttributeOIDs[] = { szOID_COMMON_NAME,
 865          szOID_ORGANIZATIONAL_UNIT_NAME, szOID_ORGANIZATION_NAME,
 866          szOID_RSA_emailAddr };
 867         CERT_NAME_INFO *info = NULL;
 868         PCERT_RDN_ATTR nameAttr = NULL;
 869         DWORD bytes = 0, i;
 870
 871         if (CryptDecodeObjectEx(pCertContext->dwCertEncodingType, X509_NAME,
 872          name->pbData, name->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &info,
 873          &bytes))
 874         {
 875             for (i = 0; !nameAttr && i < sizeof(simpleAttributeOIDs) /
 876              sizeof(simpleAttributeOIDs[0]); i++)
 877                 nameAttr = CertFindRDNAttr(simpleAttributeOIDs[i], info);
 878         }
 879         if (!nameAttr)
 880         {
 881             PCERT_EXTENSION ext = CertFindExtension(altNameOID,
 882              pCertContext->pCertInfo->cExtension,
 883              pCertContext->pCertInfo->rgExtension);
 884
 885             if (ext)
 886             {
 887                 for (i = 0; !nameAttr && i < sizeof(simpleAttributeOIDs) /
 888                  sizeof(simpleAttributeOIDs[0]); i++)
 889                     nameAttr = CertFindRDNAttr(simpleAttributeOIDs[i], info);
 890                 if (!nameAttr)
 891                 {
 892                     /* FIXME: gotta then look for a rfc822Name choice in ext.
 893                      * Failing that, look for the first attribute.
 894                      */
 895                     FIXME("CERT_NAME_SIMPLE_DISPLAY_TYPE: stub\n");
 896                 }
 897             }
 898         }
 899         if (nameAttr)
 900             ret = CertRDNValueToStrW(nameAttr->dwValueType, &nameAttr->Value,
 901                                      pszNameString, cchNameString);
 902         else
 903             ret = 0;
 904         if (info)
 905             LocalFree(info);
 906         break;
 907     }
 908     case CERT_NAME_FRIENDLY_DISPLAY_TYPE:
 909     {
 910         DWORD cch = cchNameString;
 911
 912         if (CertGetCertificateContextProperty(pCertContext,
 913          CERT_FRIENDLY_NAME_PROP_ID, pszNameString, &cch))
 914             ret = cch;
 915         else
 916             ret = CertGetNameStringW(pCertContext,
 917              CERT_NAME_SIMPLE_DISPLAY_TYPE, dwFlags, pvTypePara, pszNameString,
 918              cchNameString);
 919         break;
 920     }
 921     default:
 922         FIXME("unimplemented for type %d\n", dwType);
 923         ret = 0;
 924     }
 925     return ret;
 926 }