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