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
  20 #include "windef.h"
  21 #include "winbase.h"
  22 #include "winnls.h"
  23 #include "winuser.h"
  24 #include "wincrypt.h"
  25 #include "wine/debug.h"
  26 #include "crypt32_private.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
  29
  30 DWORD WINAPI CertRDNValueToStrA(DWORD type, PCERT_RDN_VALUE_BLOB value_blob,
  31                                 LPSTR value, DWORD value_len)
  32 {
  33     DWORD len, len_mb, ret;
  34     LPWSTR valueW;
  35
  36     TRACE("(%ld, %p, %p, %ld)\n", type, value_blob, value, value_len);
  37
  38     len = CertRDNValueToStrW(type, value_blob, NULL, 0);
  39
  40     if (!(valueW = CryptMemAlloc(len * sizeof(*valueW))))
  41     {
  42         ERR("No memory.\n");
  43         if (value && value_len) *value = 0;
  44         return 1;
  45     }
  46
  47     len = CertRDNValueToStrW(type, value_blob, valueW, len);
  48     len_mb = WideCharToMultiByte(CP_ACP, 0, valueW, len, NULL, 0, NULL, NULL);
  49     if (!value || !value_len)
  50     {
  51         CryptMemFree(valueW);
  52         return len_mb;
  53     }
  54
  55     ret = WideCharToMultiByte(CP_ACP, 0, valueW, len, value, value_len, NULL, NULL);
  56     if (ret < len_mb)
  57     {
  58         value[0] = 0;
  59         ret = 1;
  60     }
  61     CryptMemFree(valueW);
  62     return ret;
  63 }
  64
  65 static DWORD rdn_value_to_strW(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
  66                                LPWSTR psz, DWORD csz, BOOL partial_copy)
  67 {
  68     DWORD ret = 0, len, i;
  69
  70     TRACE("(%ld, %p, %p, %ld)\n", dwValueType, pValue, psz, csz);
  71
  72     switch (dwValueType)
  73     {
  74     case CERT_RDN_ANY_TYPE:
  75         break;
  76     case CERT_RDN_NUMERIC_STRING:
  77     case CERT_RDN_PRINTABLE_STRING:
  78     case CERT_RDN_TELETEX_STRING:
  79     case CERT_RDN_VIDEOTEX_STRING:
  80     case CERT_RDN_IA5_STRING:
  81     case CERT_RDN_GRAPHIC_STRING:
  82     case CERT_RDN_VISIBLE_STRING:
  83     case CERT_RDN_GENERAL_STRING:
  84         len = pValue->cbData;
  85         if (!psz || !csz) ret = len;
  86         else if (len < csz || partial_copy)
  87         {
  88             len = min(len, csz - 1);
  89             for (i = 0; i < len; ++i)
  90                 psz[i] = pValue->pbData[i];
  91             ret = len;
  92         }
  93         break;
  94     case CERT_RDN_BMP_STRING:
  95     case CERT_RDN_UTF8_STRING:
  96         len = pValue->cbData / sizeof(WCHAR);
  97         if (!psz || !csz)
  98             ret = len;
  99         else if (len < csz || partial_copy)
 100         {
 101             WCHAR *ptr = psz;
 102
 103             len = min(len, csz - 1);
 104             for (i = 0; i < len; ++i)
 105                 ptr[i] = ((LPCWSTR)pValue->pbData)[i];
 106             ret = len;
 107         }
 108         break;
 109     default:
 110         FIXME("string type %ld unimplemented\n", dwValueType);
 111     }
 112     if (psz && csz) psz[ret] = 0;
 113     TRACE("returning %ld (%s)\n", ret + 1, debugstr_w(psz));
 114     return ret + 1;
 115 }
 116
 117 DWORD WINAPI CertRDNValueToStrW(DWORD dwValueType, PCERT_RDN_VALUE_BLOB pValue,
 118                                 LPWSTR psz, DWORD csz)
 119 {
 120     return rdn_value_to_strW(dwValueType, pValue, psz, csz, FALSE);
 121 }
 122
 123 static inline BOOL is_quotable_char(WCHAR c)
 124 {
 125     switch(c)
 126     {
 127     case '+':
 128     case ',':
 129     case '"':
 130     case '=':
 131     case '<':
 132     case '>':
 133     case ';':
 134     case '#':
 135     case '\n':
 136         return TRUE;
 137     default:
 138         return FALSE;
 139     }
 140 }
 141
 142 static DWORD quote_rdn_value_to_str_w(DWORD dwValueType,
 143  PCERT_RDN_VALUE_BLOB pValue, LPWSTR psz, DWORD csz)
 144 {
 145     DWORD ret = 0, len, i, strLen;
 146     BOOL needsQuotes = FALSE;
 147
 148     TRACE("(%ld, %p, %p, %ld)\n", dwValueType, pValue, psz, csz);
 149
 150     switch (dwValueType)
 151     {
 152     case CERT_RDN_ANY_TYPE:
 153         break;
 154     case CERT_RDN_NUMERIC_STRING:
 155     case CERT_RDN_PRINTABLE_STRING:
 156     case CERT_RDN_TELETEX_STRING:
 157     case CERT_RDN_VIDEOTEX_STRING:
 158     case CERT_RDN_IA5_STRING:
 159     case CERT_RDN_GRAPHIC_STRING:
 160     case CERT_RDN_VISIBLE_STRING:
 161     case CERT_RDN_GENERAL_STRING:
 162         len = pValue->cbData;
 163         if (pValue->cbData && isspace(pValue->pbData[0]))
 164             needsQuotes = TRUE;
 165         if (pValue->cbData && isspace(pValue->pbData[pValue->cbData - 1]))
 166             needsQuotes = TRUE;
 167         for (i = 0; i < pValue->cbData; i++)
 168         {
 169             if (is_quotable_char(pValue->pbData[i]))
 170                 needsQuotes = TRUE;
 171             if (pValue->pbData[i] == '"')
 172                 len += 1;
 173         }
 174         if (needsQuotes)
 175             len += 2;
 176         if (!psz || !csz)
 177             ret = len;
 178         else
 179         {
 180             WCHAR *ptr = psz;
 181
 182             if (needsQuotes)
 183                 *ptr++ = '"';
 184             for (i = 0; i < pValue->cbData && ptr - psz < csz; ptr++, i++)
 185             {
 186                 *ptr = pValue->pbData[i];
 187                 if (pValue->pbData[i] == '"' && ptr - psz < csz - 1)
 188                     *(++ptr) = '"';
 189             }
 190             if (needsQuotes && ptr - psz < csz)
 191                 *ptr++ = '"';
 192             ret = ptr - psz;
 193         }
 194         break;
 195     case CERT_RDN_BMP_STRING:
 196     case CERT_RDN_UTF8_STRING:
 197         strLen = len = pValue->cbData / sizeof(WCHAR);
 198         if (pValue->cbData && isspace(pValue->pbData[0]))
 199             needsQuotes = TRUE;
 200         if (pValue->cbData && isspace(pValue->pbData[strLen - 1]))
 201             needsQuotes = TRUE;
 202         for (i = 0; i < strLen; i++)
 203         {
 204             if (is_quotable_char(((LPCWSTR)pValue->pbData)[i]))
 205                 needsQuotes = TRUE;
 206             if (((LPCWSTR)pValue->pbData)[i] == '"')
 207                 len += 1;
 208         }
 209         if (needsQuotes)
 210             len += 2;
 211         if (!psz || !csz)
 212             ret = len;
 213         else
 214         {
 215             WCHAR *ptr = psz;
 216
 217             if (needsQuotes)
 218                 *ptr++ = '"';
 219             for (i = 0; i < strLen && ptr - psz < csz; ptr++, i++)
 220             {
 221                 *ptr = ((LPCWSTR)pValue->pbData)[i];
 222                 if (((LPCWSTR)pValue->pbData)[i] == '"' && ptr - psz < csz - 1)
 223                     *(++ptr) = '"';
 224             }
 225             if (needsQuotes && ptr - psz < csz)
 226                 *ptr++ = '"';
 227             ret = ptr - psz;
 228         }
 229         break;
 230     default:
 231         FIXME("string type %ld unimplemented\n", dwValueType);
 232     }
 233     TRACE("returning %ld (%s)\n", ret, debugstr_w(psz));
 234     return ret;
 235 }
 236
 237 DWORD WINAPI CertNameToStrA(DWORD encoding_type, PCERT_NAME_BLOB name_blob, DWORD str_type, LPSTR str, DWORD str_len)
 238 {
 239     DWORD len, len_mb, ret;
 240     LPWSTR strW;
 241
 242     TRACE("(%ld, %p, %08lx, %p, %ld)\n", encoding_type, name_blob, str_type, str, str_len);
 243
 244     len = CertNameToStrW(encoding_type, name_blob, str_type, NULL, 0);
 245
 246     if (!(strW = CryptMemAlloc(len * sizeof(*strW))))
 247     {
 248         ERR("No memory.\n");
 249         if (str && str_len) *str = 0;
 250         return 1;
 251     }
 252
 253     len = CertNameToStrW(encoding_type, name_blob, str_type, strW, len);
 254     len_mb = WideCharToMultiByte(CP_ACP, 0, strW, len, NULL, 0, NULL, NULL);
 255     if (!str || !str_len)
 256     {
 257         CryptMemFree(strW);
 258         return len_mb;
 259     }
 260
 261     ret = WideCharToMultiByte(CP_ACP, 0, strW, len, str, str_len, NULL, NULL);
 262     if (ret < len_mb)
 263     {
 264         str[0] = 0;
 265         ret = 1;
 266     }
 267     CryptMemFree(strW);
 268     return ret;
 269 }
 270
 271 /* Adds the prefix prefix to the wide-character string pointed to by psz,
 272  * followed by the character '='.  Copies no more than csz characters.  Returns
 273  * the number of characters copied.  If psz is NULL, returns the number of
 274  * characters that would be copied.
 275  * Assumes the characters in prefix are ASCII (not multibyte characters.)
 276  */
 277 static DWORD CRYPT_AddPrefixAToW(LPCSTR prefix, LPWSTR psz, DWORD csz)
 278 {
 279     DWORD chars;
 280
 281     TRACE("(%s, %p, %ld)\n", debugstr_a(prefix), psz, csz);
 282
 283     if (psz)
 284     {
 285         DWORD i;
 286
 287         chars = min(strlen(prefix), csz);
 288         for (i = 0; i < chars; i++)
 289             *(psz + i) = prefix[i];
 290         *(psz + chars) = '=';
 291         chars++;
 292     }
 293     else
 294         chars = lstrlenA(prefix) + 1;
 295     return chars;
 296 }
 297
 298 /* Adds the prefix prefix to the string pointed to by psz, followed by the
 299  * character '='.  Copies no more than csz characters.  Returns the number of
 300  * characters copied.  If psz is NULL, returns the number of characters that
 301  * would be copied.
 302  */
 303 static DWORD CRYPT_AddPrefixW(LPCWSTR prefix, LPWSTR psz, DWORD csz)
 304 {
 305     DWORD chars;
 306
 307     TRACE("(%s, %p, %ld)\n", debugstr_w(prefix), psz, csz);
 308
 309     if (psz)
 310     {
 311         chars = min(lstrlenW(prefix), csz);
 312         memcpy(psz, prefix, chars * sizeof(WCHAR));
 313         *(psz + chars) = '=';
 314         chars++;
 315     }
 316     else
 317         chars = lstrlenW(prefix) + 1;
 318     return chars;
 319 }
 320
 321 static const WCHAR indent[] = L"     ";
 322
 323 DWORD cert_name_to_str_with_indent(DWORD dwCertEncodingType, DWORD indentLevel,
 324  const CERT_NAME_BLOB *pName, DWORD dwStrType, LPWSTR psz, DWORD csz)
 325 {
 326     static const DWORD unsupportedFlags = CERT_NAME_STR_NO_QUOTING_FLAG |
 327      CERT_NAME_STR_ENABLE_T61_UNICODE_FLAG;
 328     DWORD ret = 0, bytes = 0;
 329     BOOL bRet;
 330     CERT_NAME_INFO *info;
 331     DWORD chars;
 332
 333     if (dwStrType & unsupportedFlags)
 334         FIXME("unsupported flags: %08lx\n", dwStrType & unsupportedFlags);
 335
 336     bRet = CryptDecodeObjectEx(dwCertEncodingType, X509_NAME, pName->pbData,
 337      pName->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &bytes);
 338     if (bRet)
 339     {
 340         DWORD i, j, sepLen, rdnSepLen;
 341         LPCWSTR sep, rdnSep;
 342         BOOL reverse = dwStrType & CERT_NAME_STR_REVERSE_FLAG;
 343         const CERT_RDN *rdn = info->rgRDN;
 344
 345         if(reverse && info->cRDN > 1) rdn += (info->cRDN - 1);
 346
 347         if (dwStrType & CERT_NAME_STR_SEMICOLON_FLAG)
 348             sep = L"; ";
 349         else if (dwStrType & CERT_NAME_STR_CRLF_FLAG)
 350             sep = L"\r\n";
 351         else
 352             sep = L", ";
 353         sepLen = lstrlenW(sep);
 354         if (dwStrType & CERT_NAME_STR_NO_PLUS_FLAG)
 355             rdnSep = L" ";
 356         else
 357             rdnSep = L" + ";
 358         rdnSepLen = lstrlenW(rdnSep);
 359         if (!csz) psz = NULL;
 360         for (i = 0; i < info->cRDN; i++)
 361         {
 362             if (psz && ret + 1 == csz) break;
 363             for (j = 0; j < rdn->cRDNAttr; j++)
 364             {
 365                 LPCSTR prefixA = NULL;
 366                 LPCWSTR prefixW = NULL;
 367
 368                 if (psz && ret + 1 == csz) break;
 369
 370                 if ((dwStrType & 0x000000ff) == CERT_OID_NAME_STR)
 371                     prefixA = rdn->rgRDNAttr[j].pszObjId;
 372                 else if ((dwStrType & 0x000000ff) == CERT_X500_NAME_STR)
 373                 {
 374                     PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(
 375                      CRYPT_OID_INFO_OID_KEY,
 376                      rdn->rgRDNAttr[j].pszObjId,
 377                      CRYPT_RDN_ATTR_OID_GROUP_ID);
 378
 379                     if (oidInfo)
 380                         prefixW = oidInfo->pwszName;
 381                     else
 382                         prefixA = rdn->rgRDNAttr[j].pszObjId;
 383                 }
 384                 if (dwStrType & CERT_NAME_STR_CRLF_FLAG)
 385                 {
 386                     DWORD k;
 387
 388                     for (k = 0; k < indentLevel; k++)
 389                     {
 390                         if (psz)
 391                         {
 392                             chars = min(lstrlenW(indent), csz - ret - 1);
 393                             memcpy(psz + ret, indent, chars * sizeof(WCHAR));
 394                         }
 395                         else
 396                             chars = lstrlenW(indent);
 397                         ret += chars;
 398                     }
 399                     if (psz && ret + 1 == csz) break;
 400                 }
 401                 if (prefixW)
 402                 {
 403                     /* - 1 is needed to account for the NULL terminator. */
 404                     chars = CRYPT_AddPrefixW(prefixW,
 405                      psz ? psz + ret : NULL, psz ? csz - ret - 1 : 0);
 406                     ret += chars;
 407                 }
 408                 else if (prefixA)
 409                 {
 410                     /* - 1 is needed to account for the NULL terminator. */
 411                     chars = CRYPT_AddPrefixAToW(prefixA,
 412                      psz ? psz + ret : NULL, psz ? csz - ret - 1 : 0);
 413                     ret += chars;
 414                 }
 415                 if (psz && ret + 1 == csz) break;
 416
 417                 chars = quote_rdn_value_to_str_w(rdn->rgRDNAttr[j].dwValueType, &rdn->rgRDNAttr[j].Value,
 418                                                  psz ? psz + ret : NULL, psz ? csz - ret - 1 : 0);
 419                 ret += chars;
 420                 if (j < rdn->cRDNAttr - 1)
 421                 {
 422                     if (psz)
 423                     {
 424                         chars = min(rdnSepLen, csz - ret - 1);
 425                         memcpy(psz + ret, rdnSep, chars * sizeof(WCHAR));
 426                         ret += chars;
 427                     }
 428                     else ret += rdnSepLen;
 429                 }
 430             }
 431             if (psz && ret + 1 == csz) break;
 432             if (i < info->cRDN - 1)
 433             {
 434                 if (psz)
 435                 {
 436                     chars = min(sepLen, csz - ret - 1);
 437                     memcpy(psz + ret, sep, chars * sizeof(WCHAR));
 438                     ret += chars;
 439                 }
 440                 else ret += sepLen;
 441             }
 442             if(reverse) rdn--;
 443             else rdn++;
 444         }
 445         LocalFree(info);
 446     }
 447     if (psz && csz) psz[ret] = 0;
 448     return ret + 1;
 449 }
 450
 451 DWORD WINAPI CertNameToStrW(DWORD dwCertEncodingType, PCERT_NAME_BLOB pName,
 452  DWORD dwStrType, LPWSTR psz, DWORD csz)
 453 {
 454     BOOL ret;
 455
 456     TRACE("(%ld, %p, %08lx, %p, %ld)\n", dwCertEncodingType, pName, dwStrType,
 457      psz, csz);
 458
 459     ret = cert_name_to_str_with_indent(dwCertEncodingType, 0, pName, dwStrType,
 460      psz, csz);
 461     TRACE("Returning %s\n", debugstr_w(psz));
 462     return ret;
 463 }
 464
 465 BOOL WINAPI CertStrToNameA(DWORD dwCertEncodingType, LPCSTR pszX500,
 466  DWORD dwStrType, void *pvReserved, BYTE *pbEncoded, DWORD *pcbEncoded,
 467  LPCSTR *ppszError)
 468 {
 469     BOOL ret;
 470     int len;
 471
 472     TRACE("(%08lx, %s, %08lx, %p, %p, %p, %p)\n", dwCertEncodingType,
 473      debugstr_a(pszX500), dwStrType, pvReserved, pbEncoded, pcbEncoded,
 474      ppszError);
 475
 476     len = MultiByteToWideChar(CP_ACP, 0, pszX500, -1, NULL, 0);
 477     if (len)
 478     {
 479         LPWSTR x500, errorStr;
 480
 481         if ((x500 = CryptMemAlloc(len * sizeof(WCHAR))))
 482         {
 483             MultiByteToWideChar(CP_ACP, 0, pszX500, -1, x500, len);
 484             ret = CertStrToNameW(dwCertEncodingType, x500, dwStrType,
 485              pvReserved, pbEncoded, pcbEncoded,
 486              ppszError ? (LPCWSTR *)&errorStr : NULL);
 487             if (ppszError)
 488             {
 489                 if (!ret)
 490                 {
 491                     LONG i;
 492
 493                     *ppszError = pszX500;
 494                     for (i = 0; i < errorStr - x500; i++)
 495                         *ppszError = CharNextA(*ppszError);
 496                 }
 497                 else
 498                     *ppszError = NULL;
 499             }
 500             CryptMemFree(x500);
 501         }
 502         else
 503         {
 504             SetLastError(ERROR_OUTOFMEMORY);
 505             ret = FALSE;
 506         }
 507     }
 508     else
 509     {
 510         SetLastError(CRYPT_E_INVALID_X500_STRING);
 511         if (ppszError)
 512             *ppszError = pszX500;
 513         ret = FALSE;
 514     }
 515     return ret;
 516 }
 517
 518 struct KeynameKeeper
 519 {
 520     WCHAR  buf[10]; /* big enough for L"GivenName" */
 521     LPWSTR keyName; /* usually = buf, but may be allocated */
 522     DWORD  keyLen;  /* full available buffer size in WCHARs */
 523 };
 524
 525 static void CRYPT_InitializeKeynameKeeper(struct KeynameKeeper *keeper)
 526 {
 527     keeper->keyName = keeper->buf;
 528     keeper->keyLen = ARRAY_SIZE(keeper->buf);
 529 }
 530
 531 static void CRYPT_FreeKeynameKeeper(struct KeynameKeeper *keeper)
 532 {
 533     if (keeper->keyName != keeper->buf)
 534         CryptMemFree(keeper->keyName);
 535 }
 536
 537 struct X500TokenW
 538 {
 539     LPCWSTR start;
 540     LPCWSTR end;
 541 };
 542
 543 static void CRYPT_KeynameKeeperFromTokenW(struct KeynameKeeper *keeper,
 544  const struct X500TokenW *key)
 545 {
 546     DWORD len = key->end - key->start;
 547
 548     if (len >= keeper->keyLen)
 549     {
 550         CRYPT_FreeKeynameKeeper( keeper );
 551         keeper->keyLen = len + 1;
 552         keeper->keyName = CryptMemAlloc(keeper->keyLen * sizeof(WCHAR));
 553     }
 554     memcpy(keeper->keyName, key->start, len * sizeof(WCHAR));
 555     keeper->keyName[len] = '\0';
 556     TRACE("Keyname is %s\n", debugstr_w(keeper->keyName));
 557 }
 558
 559 static BOOL CRYPT_GetNextKeyW(LPCWSTR str, struct X500TokenW *token,
 560  LPCWSTR *ppszError)
 561 {
 562     BOOL ret = TRUE;
 563
 564     while (*str && iswspace(*str))
 565         str++;
 566     if (*str)
 567     {
 568         token->start = str;
 569         while (*str && *str != '=' && !iswspace(*str))
 570             str++;
 571         if (*str && (*str == '=' || iswspace(*str)))
 572             token->end = str;
 573         else
 574         {
 575             TRACE("missing equals char at %s\n", debugstr_w(token->start));
 576             if (ppszError)
 577                 *ppszError = token->start;
 578             SetLastError(CRYPT_E_INVALID_X500_STRING);
 579             ret = FALSE;
 580         }
 581     }
 582     else
 583         token->start = NULL;
 584     return ret;
 585 }
 586
 587 /* Assumes separators are characters in the 0-255 range */
 588 static BOOL CRYPT_GetNextValueW(LPCWSTR str, DWORD dwFlags, LPCWSTR separators,
 589  WCHAR *separator_used, struct X500TokenW *token, LPCWSTR *ppszError)
 590 {
 591     BOOL ret = TRUE;
 592
 593     TRACE("(%s, %s, %p, %p)\n", debugstr_w(str), debugstr_w(separators), token,
 594      ppszError);
 595
 596     *separator_used = 0;
 597     while (*str && iswspace(*str))
 598         str++;
 599     if (*str)
 600     {
 601         token->start = str;
 602         if (!(dwFlags & CERT_NAME_STR_NO_QUOTING_FLAG) && *str == '"')
 603         {
 604             token->end = NULL;
 605             str++;
 606             while (!token->end && ret)
 607             {
 608                 while (*str && *str != '"')
 609                     str++;
 610                 if (*str == '"')
 611                 {
 612                     if (*(str + 1) != '"')
 613                         token->end = str + 1;
 614                     else
 615                         str += 2;
 616                 }
 617                 else
 618                 {
 619                     TRACE("unterminated quote at %s\n", debugstr_w(str));
 620                     if (ppszError)
 621                         *ppszError = str;
 622                     SetLastError(CRYPT_E_INVALID_X500_STRING);
 623                     ret = FALSE;
 624                 }
 625             }
 626         }
 627         else
 628         {
 629             WCHAR map[256] = { 0 };
 630
 631             while (*separators)
 632                 map[*separators++] = 1;
 633             while (*str && (*str >= 0xff || !map[*str]))
 634                 str++;
 635             token->end = str;
 636             if (map[*str]) *separator_used = *str;
 637         }
 638     }
 639     else
 640     {
 641         TRACE("missing value at %s\n", debugstr_w(str));
 642         if (ppszError)
 643             *ppszError = str;
 644         SetLastError(CRYPT_E_INVALID_X500_STRING);
 645         ret = FALSE;
 646     }
 647     return ret;
 648 }
 649
 650 /* Encodes the string represented by value as the string type type into the
 651  * CERT_NAME_BLOB output.  If there is an error and ppszError is not NULL,
 652  * *ppszError is set to the first failing character.  If there is no error,
 653  * output's pbData must be freed with LocalFree.
 654  */
 655 static BOOL CRYPT_EncodeValueWithType(DWORD dwCertEncodingType,
 656  const struct X500TokenW *value, PCERT_NAME_BLOB output, DWORD type,
 657  LPCWSTR *ppszError)
 658 {
 659     CERT_NAME_VALUE nameValue = { type, { 0, NULL } };
 660     BOOL ret = TRUE;
 661
 662     if (value->end > value->start)
 663     {
 664         LONG i;
 665         LPWSTR ptr;
 666
 667         nameValue.Value.pbData = CryptMemAlloc((value->end - value->start + 1) *
 668          sizeof(WCHAR));
 669         if (!nameValue.Value.pbData)
 670         {
 671             SetLastError(ERROR_OUTOFMEMORY);
 672             return FALSE;
 673         }
 674         ptr = (LPWSTR)nameValue.Value.pbData;
 675         for (i = 0; i < value->end - value->start; i++)
 676         {
 677             *ptr++ = value->start[i];
 678             if (value->start[i] == '"')
 679                 i++;
 680         }
 681         /* The string is NULL terminated because of a quirk in encoding
 682          * unicode names values:  if the length is given as 0, the value is
 683          * assumed to be a NULL-terminated string.
 684          */
 685         *ptr = 0;
 686         nameValue.Value.cbData = (LPBYTE)ptr - nameValue.Value.pbData;
 687     }
 688     ret = CryptEncodeObjectEx(dwCertEncodingType, X509_UNICODE_NAME_VALUE,
 689      &nameValue, CRYPT_ENCODE_ALLOC_FLAG, NULL, &output->pbData,
 690      &output->cbData);
 691     if (!ret && ppszError)
 692     {
 693         if (type == CERT_RDN_NUMERIC_STRING &&
 694          GetLastError() == CRYPT_E_INVALID_NUMERIC_STRING)
 695             *ppszError = value->start + output->cbData;
 696         else if (type == CERT_RDN_PRINTABLE_STRING &&
 697          GetLastError() == CRYPT_E_INVALID_PRINTABLE_STRING)
 698             *ppszError = value->start + output->cbData;
 699         else if (type == CERT_RDN_IA5_STRING &&
 700          GetLastError() == CRYPT_E_INVALID_IA5_STRING)
 701             *ppszError = value->start + output->cbData;
 702     }
 703     CryptMemFree(nameValue.Value.pbData);
 704     return ret;
 705 }
 706
 707 static BOOL CRYPT_EncodeValue(DWORD dwCertEncodingType,
 708  const struct X500TokenW *value, PCERT_NAME_BLOB output, const DWORD *types,
 709  LPCWSTR *ppszError)
 710 {
 711     DWORD i;
 712     BOOL ret;
 713
 714     ret = FALSE;
 715     for (i = 0; !ret && types[i]; i++)
 716         ret = CRYPT_EncodeValueWithType(dwCertEncodingType, value, output,
 717          types[i], ppszError);
 718     return ret;
 719 }
 720
 721 static BOOL CRYPT_ValueToRDN(DWORD dwCertEncodingType, PCERT_NAME_INFO info,
 722  PCCRYPT_OID_INFO keyOID, struct X500TokenW *value, DWORD dwStrType, LPCWSTR *ppszError)
 723 {
 724     BOOL ret = FALSE;
 725
 726     TRACE("OID %s, value %s\n", debugstr_a(keyOID->pszOID),
 727      debugstr_wn(value->start, value->end - value->start));
 728
 729     if (!info->rgRDN)
 730         info->rgRDN = CryptMemAlloc(sizeof(CERT_RDN));
 731     else
 732         info->rgRDN = CryptMemRealloc(info->rgRDN,
 733          (info->cRDN + 1) * sizeof(CERT_RDN));
 734     if (info->rgRDN)
 735     {
 736         /* FIXME: support multiple RDN attrs */
 737         info->rgRDN[info->cRDN].rgRDNAttr =
 738          CryptMemAlloc(sizeof(CERT_RDN_ATTR));
 739         if (info->rgRDN[info->cRDN].rgRDNAttr)
 740         {
 741             static const DWORD defaultTypes[] = { CERT_RDN_PRINTABLE_STRING,
 742              CERT_RDN_BMP_STRING, 0 };
 743             const DWORD *types;
 744
 745             info->rgRDN[info->cRDN].cRDNAttr = 1;
 746             info->rgRDN[info->cRDN].rgRDNAttr[0].pszObjId =
 747              (LPSTR)keyOID->pszOID;
 748             info->rgRDN[info->cRDN].rgRDNAttr[0].dwValueType =
 749              CERT_RDN_ENCODED_BLOB;
 750             if (keyOID->ExtraInfo.cbData)
 751                 types = (const DWORD *)keyOID->ExtraInfo.pbData;
 752             else
 753                 types = defaultTypes;
 754
 755             /* Remove surrounding quotes */
 756             if (value->start[0] == '"' && !(dwStrType & CERT_NAME_STR_NO_QUOTING_FLAG))
 757             {
 758                 value->start++;
 759                 value->end--;
 760             }
 761             ret = CRYPT_EncodeValue(dwCertEncodingType, value,
 762              &info->rgRDN[info->cRDN].rgRDNAttr[0].Value, types, ppszError);
 763         }
 764         else
 765             SetLastError(ERROR_OUTOFMEMORY);
 766         info->cRDN++;
 767     }
 768     else
 769         SetLastError(ERROR_OUTOFMEMORY);
 770     return ret;
 771 }
 772
 773 BOOL WINAPI CertStrToNameW(DWORD dwCertEncodingType, LPCWSTR pszX500,
 774  DWORD dwStrType, void *pvReserved, BYTE *pbEncoded, DWORD *pcbEncoded,
 775  LPCWSTR *ppszError)
 776 {
 777     CERT_NAME_INFO info = { 0, NULL };
 778     LPCWSTR str;
 779     struct KeynameKeeper keeper;
 780     DWORD i;
 781     BOOL ret = TRUE;
 782
 783     TRACE("(%08lx, %s, %08lx, %p, %p, %p, %p)\n", dwCertEncodingType,
 784      debugstr_w(pszX500), dwStrType, pvReserved, pbEncoded, pcbEncoded,
 785      ppszError);
 786
 787     CRYPT_InitializeKeynameKeeper(&keeper);
 788     str = pszX500;
 789     while (str && *str && ret)
 790     {
 791         struct X500TokenW token;
 792
 793         ret = CRYPT_GetNextKeyW(str, &token, ppszError);
 794         if (ret && token.start)
 795         {
 796             PCCRYPT_OID_INFO keyOID;
 797
 798             CRYPT_KeynameKeeperFromTokenW(&keeper, &token);
 799             keyOID = CryptFindOIDInfo(CRYPT_OID_INFO_NAME_KEY, keeper.keyName,
 800              CRYPT_RDN_ATTR_OID_GROUP_ID);
 801             if (!keyOID)
 802             {
 803                 if (ppszError)
 804                     *ppszError = token.start;
 805                 SetLastError(CRYPT_E_INVALID_X500_STRING);
 806                 ret = FALSE;
 807             }
 808             else
 809             {
 810                 str = token.end;
 811                 while (iswspace(*str))
 812                     str++;
 813                 if (*str != '=')
 814                 {
 815                     if (ppszError)
 816                         *ppszError = str;
 817                     SetLastError(CRYPT_E_INVALID_X500_STRING);
 818                     ret = FALSE;
 819                 }
 820                 else
 821                 {
 822                     LPCWSTR sep;
 823                     WCHAR sep_used;
 824
 825                     str++;
 826                     if (dwStrType & CERT_NAME_STR_COMMA_FLAG)
 827                         sep = L",";
 828                     else if (dwStrType & CERT_NAME_STR_SEMICOLON_FLAG)
 829                         sep = L";";
 830                     else if (dwStrType & CERT_NAME_STR_CRLF_FLAG)
 831                         sep = L"\r\n";
 832                     else if (dwStrType & CERT_NAME_STR_NO_PLUS_FLAG)
 833                         sep = L",;\r\n";
 834                     else
 835                         sep = L"+,;\r\n";
 836                     ret = CRYPT_GetNextValueW(str, dwStrType, sep, &sep_used, &token,
 837                      ppszError);
 838                     if (ret)
 839                     {
 840                         str = token.end;
 841                         /* if token.end points to the separator, skip it */
 842                         if (str && sep_used && *str == sep_used) str++;
 843
 844                         ret = CRYPT_ValueToRDN(dwCertEncodingType, &info,
 845                          keyOID, &token, dwStrType, ppszError);
 846                     }
 847                 }
 848             }
 849         }
 850     }
 851     CRYPT_FreeKeynameKeeper(&keeper);
 852     if (ret)
 853     {
 854         if (ppszError)
 855             *ppszError = NULL;
 856         ret = CryptEncodeObjectEx(dwCertEncodingType, X509_NAME, &info,
 857          0, NULL, pbEncoded, pcbEncoded);
 858     }
 859     for (i = 0; i < info.cRDN; i++)
 860     {
 861         DWORD j;
 862
 863         for (j = 0; j < info.rgRDN[i].cRDNAttr; j++)
 864             LocalFree(info.rgRDN[i].rgRDNAttr[j].Value.pbData);
 865         CryptMemFree(info.rgRDN[i].rgRDNAttr);
 866     }
 867     CryptMemFree(info.rgRDN);
 868     return ret;
 869 }
 870
 871 DWORD WINAPI CertGetNameStringA(PCCERT_CONTEXT cert, DWORD type,
 872                                 DWORD flags, void *type_para, LPSTR name, DWORD name_len)
 873 {
 874     DWORD len, len_mb, ret;
 875     LPWSTR nameW;
 876
 877     TRACE("(%p, %ld, %08lx, %p, %p, %ld)\n", cert, type, flags, type_para, name, name_len);
 878
 879     len = CertGetNameStringW(cert, type, flags, type_para, NULL, 0);
 880
 881     if (!(nameW = CryptMemAlloc(len * sizeof(*nameW))))
 882     {
 883         ERR("No memory.\n");
 884         if (name && name_len) *name = 0;
 885         return 1;
 886     }
 887
 888     len = CertGetNameStringW(cert, type, flags, type_para, nameW, len);
 889     len_mb = WideCharToMultiByte(CP_ACP, 0, nameW, len, NULL, 0, NULL, NULL);
 890     if (!name || !name_len)
 891     {
 892         CryptMemFree(nameW);
 893         return len_mb;
 894     }
 895
 896     ret = WideCharToMultiByte(CP_ACP, 0, nameW, len, name, name_len, NULL, NULL);
 897     if (ret < len_mb)
 898     {
 899         name[0] = 0;
 900         ret = 1;
 901     }
 902     CryptMemFree(nameW);
 903     return ret;
 904 }
 905
 906 static BOOL cert_get_alt_name_info(PCCERT_CONTEXT cert, BOOL alt_name_issuer, PCERT_ALT_NAME_INFO *info)
 907 {
 908     static const char *oids[][2] =
 909     {
 910         { szOID_SUBJECT_ALT_NAME2, szOID_SUBJECT_ALT_NAME },
 911         { szOID_ISSUER_ALT_NAME2, szOID_ISSUER_ALT_NAME },
 912     };
 913     PCERT_EXTENSION ext;
 914     DWORD bytes = 0;
 915
 916     ext = CertFindExtension(oids[!!alt_name_issuer][0], cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
 917     if (!ext)
 918         ext = CertFindExtension(oids[!!alt_name_issuer][1], cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension);
 919     if (!ext) return FALSE;
 920
 921     return CryptDecodeObjectEx(cert->dwCertEncodingType, X509_ALTERNATE_NAME, ext->Value.pbData, ext->Value.cbData,
 922                              CRYPT_DECODE_ALLOC_FLAG, NULL, info, &bytes);
 923 }
 924
 925 static PCERT_ALT_NAME_ENTRY cert_find_next_alt_name_entry(PCERT_ALT_NAME_INFO info, DWORD entry_type,
 926                                                           unsigned int *index)
 927 {
 928     unsigned int i;
 929
 930     for (i = *index; i < info->cAltEntry; ++i)
 931         if (info->rgAltEntry[i].dwAltNameChoice == entry_type)
 932         {
 933             *index = i + 1;
 934             return &info->rgAltEntry[i];
 935         }
 936     return NULL;
 937 }
 938
 939 /* Searches cert's extensions for the alternate name extension with OID
 940  * altNameOID, and if found, searches it for the alternate name type entryType.
 941  * If found, returns a pointer to the entry, otherwise returns NULL.
 942  * Regardless of whether an entry of the desired type is found, if the
 943  * alternate name extension is present, sets *info to the decoded alternate
 944  * name extension, which you must free using LocalFree.
 945  * The return value is a pointer within *info, so don't free *info before
 946  * you're done with the return value.
 947  */
 948 static PCERT_ALT_NAME_ENTRY cert_find_alt_name_entry(PCCERT_CONTEXT cert, BOOL alt_name_issuer,
 949                                                      DWORD entry_type, PCERT_ALT_NAME_INFO *info)
 950 {
 951     unsigned int index = 0;
 952
 953     if (!cert_get_alt_name_info(cert, alt_name_issuer, info)) return NULL;
 954     return cert_find_next_alt_name_entry(*info, entry_type, &index);
 955 }
 956
 957 static DWORD cert_get_name_from_rdn_attr(DWORD encodingType,
 958  const CERT_NAME_BLOB *name, LPCSTR oid, LPWSTR pszNameString, DWORD cchNameString)
 959 {
 960     CERT_NAME_INFO *nameInfo;
 961     DWORD bytes = 0, ret = 0;
 962
 963     if (CryptDecodeObjectEx(encodingType, X509_NAME, name->pbData,
 964      name->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &nameInfo, &bytes))
 965     {
 966         PCERT_RDN_ATTR nameAttr = NULL;
 967
 968         if (oid)
 969             nameAttr = CertFindRDNAttr(oid, nameInfo);
 970         else
 971         {
 972             static const LPCSTR attributeOIDs[] =
 973             {
 974                 szOID_RSA_emailAddr, szOID_COMMON_NAME,
 975                 szOID_ORGANIZATIONAL_UNIT_NAME, szOID_ORGANIZATION_NAME
 976             };
 977             DWORD i;
 978
 979             for (i = 0; !nameAttr && i < ARRAY_SIZE(attributeOIDs); i++)
 980                 nameAttr = CertFindRDNAttr(attributeOIDs[i], nameInfo);
 981         }
 982         if (nameAttr)
 983             ret = rdn_value_to_strW(nameAttr->dwValueType, &nameAttr->Value,
 984              pszNameString, cchNameString, TRUE);
 985         LocalFree(nameInfo);
 986     }
 987     return ret;
 988 }
 989
 990 static DWORD copy_output_str(WCHAR *dst, const WCHAR *src, DWORD dst_size)
 991 {
 992     DWORD len = wcslen(src);
 993
 994     if (!dst || !dst_size) return len + 1;
 995     len = min(len, dst_size - 1);
 996     memcpy(dst, src, len * sizeof(*dst));
 997     dst[len] = 0;
 998     return len + 1;
 999 }
1000
1001 DWORD WINAPI CertGetNameStringW(PCCERT_CONTEXT cert, DWORD type, DWORD flags, void *type_para,
1002                                 LPWSTR name_string, DWORD name_len)
1003 {
1004     static const DWORD supported_flags = CERT_NAME_ISSUER_FLAG | CERT_NAME_SEARCH_ALL_NAMES_FLAG;
1005     BOOL alt_name_issuer, search_all_names;
1006     CERT_ALT_NAME_INFO *info = NULL;
1007     PCERT_ALT_NAME_ENTRY entry;
1008     PCERT_NAME_BLOB name;
1009     DWORD ret = 0;
1010
1011     TRACE("(%p, %ld, %08lx, %p, %p, %ld)\n", cert, type, flags, type_para, name_string, name_len);
1012
1013     if (!cert)
1014         goto done;
1015
1016     if (flags & ~supported_flags)
1017         FIXME("Unsupported flags %#lx.\n", flags);
1018
1019     search_all_names = flags & CERT_NAME_SEARCH_ALL_NAMES_FLAG;
1020     if (search_all_names && type != CERT_NAME_DNS_TYPE)
1021     {
1022         WARN("CERT_NAME_SEARCH_ALL_NAMES_FLAG used with type %lu.\n", type);
1023         goto done;
1024     }
1025
1026     alt_name_issuer = flags & CERT_NAME_ISSUER_FLAG;
1027     name = alt_name_issuer ? &cert->pCertInfo->Issuer : &cert->pCertInfo->Subject;
1028
1029     switch (type)
1030     {
1031     case CERT_NAME_EMAIL_TYPE:
1032     {
1033         entry = cert_find_alt_name_entry(cert, alt_name_issuer, CERT_ALT_NAME_RFC822_NAME, &info);
1034
1035         if (entry)
1036         {
1037             ret = copy_output_str(name_string, entry->pwszRfc822Name, name_len);
1038             break;
1039         }
1040         ret = cert_get_name_from_rdn_attr(cert->dwCertEncodingType, name, szOID_RSA_emailAddr,
1041                                           name_string, name_len);
1042         break;
1043     }
1044     case CERT_NAME_RDN_TYPE:
1045     {
1046         DWORD param = type_para ? *(DWORD *)type_para : 0;
1047
1048         if (name->cbData)
1049         {
1050             ret = CertNameToStrW(cert->dwCertEncodingType, name, param, name_string, name_len);
1051         }
1052         else
1053         {
1054             entry = cert_find_alt_name_entry(cert, alt_name_issuer, CERT_ALT_NAME_DIRECTORY_NAME, &info);
1055
1056             if (entry)
1057                 ret = CertNameToStrW(cert->dwCertEncodingType, &entry->DirectoryName,
1058                                      param, name_string, name_len);
1059         }
1060         break;
1061     }
1062     case CERT_NAME_ATTR_TYPE:
1063         ret = cert_get_name_from_rdn_attr(cert->dwCertEncodingType, name, type_para,
1064                                           name_string, name_len);
1065         if (ret) break;
1066
1067         entry = cert_find_alt_name_entry(cert, alt_name_issuer, CERT_ALT_NAME_DIRECTORY_NAME, &info);
1068
1069         if (entry)
1070             ret = cert_name_to_str_with_indent(X509_ASN_ENCODING, 0, &entry->DirectoryName,
1071                                                0, name_string, name_len);
1072         break;
1073     case CERT_NAME_SIMPLE_DISPLAY_TYPE:
1074     {
1075         static const LPCSTR simpleAttributeOIDs[] =
1076         {
1077             szOID_COMMON_NAME, szOID_ORGANIZATIONAL_UNIT_NAME, szOID_ORGANIZATION_NAME, szOID_RSA_emailAddr
1078         };
1079         CERT_NAME_INFO *nameInfo = NULL;
1080         DWORD bytes = 0, i;
1081
1082         if (CryptDecodeObjectEx(cert->dwCertEncodingType, X509_NAME, name->pbData, name->cbData,
1083                                 CRYPT_DECODE_ALLOC_FLAG, NULL, &nameInfo, &bytes))
1084         {
1085             PCERT_RDN_ATTR nameAttr = NULL;
1086
1087             for (i = 0; !nameAttr && i < ARRAY_SIZE(simpleAttributeOIDs); i++)
1088                 nameAttr = CertFindRDNAttr(simpleAttributeOIDs[i], nameInfo);
1089             if (nameAttr)
1090                 ret = rdn_value_to_strW(nameAttr->dwValueType, &nameAttr->Value, name_string, name_len, TRUE);
1091             LocalFree(nameInfo);
1092         }
1093         if (ret) break;
1094         entry = cert_find_alt_name_entry(cert, alt_name_issuer, CERT_ALT_NAME_RFC822_NAME, &info);
1095         if (!info) break;
1096         if (!entry && info->cAltEntry)
1097             entry = &info->rgAltEntry[0];
1098         if (entry) ret = copy_output_str(name_string, entry->pwszRfc822Name, name_len);
1099         break;
1100     }
1101     case CERT_NAME_FRIENDLY_DISPLAY_TYPE:
1102     {
1103         DWORD len = name_len;
1104
1105         if (CertGetCertificateContextProperty(cert, CERT_FRIENDLY_NAME_PROP_ID, name_string, &len))
1106             ret = len;
1107         else
1108             ret = CertGetNameStringW(cert, CERT_NAME_SIMPLE_DISPLAY_TYPE, flags,
1109                                      type_para, name_string, name_len);
1110         break;
1111     }
1112     case CERT_NAME_DNS_TYPE:
1113     {
1114         unsigned int index = 0, len;
1115
1116         if (cert_get_alt_name_info(cert, alt_name_issuer, &info)
1117             && (entry = cert_find_next_alt_name_entry(info, CERT_ALT_NAME_DNS_NAME, &index)))
1118         {
1119             if (search_all_names)
1120             {
1121                 do
1122                 {
1123                     if (name_string && name_len == 1) break;
1124                     ret += len = copy_output_str(name_string, entry->pwszDNSName, name_len ? name_len - 1 : 0);
1125                     if (name_string && name_len)
1126                     {
1127                         name_string += len;
1128                         name_len -= len;
1129                     }
1130                 }
1131                 while ((entry = cert_find_next_alt_name_entry(info, CERT_ALT_NAME_DNS_NAME, &index)));
1132             }
1133             else ret = copy_output_str(name_string, entry->pwszDNSName, name_len);
1134         }
1135         else
1136         {
1137             if (!search_all_names || name_len != 1)
1138             {
1139                 len = search_all_names && name_len ? name_len - 1 : name_len;
1140                 ret = cert_get_name_from_rdn_attr(cert->dwCertEncodingType, name, szOID_COMMON_NAME,
1141                                                   name_string, len);
1142                 if (name_string) name_string += ret;
1143             }
1144         }
1145
1146         if (search_all_names)
1147         {
1148             if (name_string && name_len) *name_string = 0;
1149             ++ret;
1150         }
1151         break;
1152     }
1153     case CERT_NAME_URL_TYPE:
1154     {
1155         if ((entry = cert_find_alt_name_entry(cert, alt_name_issuer, CERT_ALT_NAME_URL, &info)))
1156             ret = copy_output_str(name_string, entry->pwszURL, name_len);
1157         break;
1158     }
1159     default:
1160         FIXME("unimplemented for type %lu.\n", type);
1161         ret = 0;
1162         break;
1163     }
1164 done:
1165     if (info)
1166         LocalFree(info);
1167
1168     if (!ret)
1169     {
1170         ret = 1;
1171         if (name_string && name_len) name_string[0] = 0;
1172     }
1173     return ret;
1174 }