xmlsecurity/source/dialogs/resourcemanager.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "resourcemanager.hxx"
  22
  23 #include <vcl/svapp.hxx>
  24 #include <vcl/fixed.hxx>
  25 #include <svl/solar.hrc>
  26 #include <unotools/syslocale.hxx>
  27 #include <rtl/ustring.h>
  28 #include <rtl/ustrbuf.h>
  29 #include <vector>
  30
  31 using namespace std;
  32
  33 namespace XmlSec
  34 {
  35     static ResMgr*          pResMgr = nullptr;
  36     static SvtSysLocale*    pSysLocale = nullptr;
  37
  38     ResMgr* GetResMgr()
  39     {
  40         if (!pResMgr)
  41             pResMgr = ResMgr::CreateResMgr("xmlsec");
  42         return pResMgr;
  43     }
  44
  45     const LocaleDataWrapper&    GetLocaleData()
  46     {
  47         if (!pSysLocale)
  48             pSysLocale = new SvtSysLocale;
  49         return pSysLocale->GetLocaleData();
  50     }
  51
  52     DateTime GetDateTime( const css::util::DateTime& _rDT )
  53     {
  54         return DateTime(_rDT);
  55     }
  56
  57     OUString GetDateTimeString( const css::util::DateTime& _rDT )
  58     {
  59         // String with date and time information (#i20172#)
  60         DateTime aDT( GetDateTime( _rDT ) );
  61         const LocaleDataWrapper& rLoDa = GetLocaleData();
  62
  63         return  rLoDa.getDate( aDT ) + " " + rLoDa.getTime( aDT );
  64     }
  65
  66     OUString GetDateString( const css::util::DateTime& _rDT )
  67     {
  68         return GetLocaleData().getDate( GetDateTime( _rDT ) );
  69     }
  70
  71     OUString GetCertificateKind( const css::security::CertificateKind &rKind )
  72     {
  73         switch (rKind)
  74         {
  75             case css::security::CertificateKind_X509:
  76                 return OUString("X.509");
  77             case css::security::CertificateKind_OPENPGP:
  78                 return OUString("OpenPGP");
  79             default:
  80                 return OUString();
  81         }
  82     }
  83
  84     /*
  85         Creates two strings based on the distinguished name which are displayed in the
  86         certificate details view. The first string contains only the values of the attribute
  87         and values pairs, which are separated by commas. All escape characters ('"') are
  88         removed.
  89         The second string is for the details view at the bottom. It shows the attribute/value
  90         pairs on different lines. All escape characters ('"') are removed.
  91     */
  92     pair< OUString, OUString> GetDNForCertDetailsView( const OUString & rRawString)
  93     {
  94         vector< pair< OUString, OUString > > vecAttrValueOfDN = parseDN(rRawString);
  95         OUStringBuffer s1, s2;
  96         typedef vector< pair < OUString, OUString > >::const_iterator CIT;
  97         for (CIT i = vecAttrValueOfDN.begin(); i < vecAttrValueOfDN.end(); ++i)
  98         {
  99             if (i != vecAttrValueOfDN.begin())
 100             {
 101                 s1.append(',');
 102                 s2.append('\n');
 103             }
 104             s1.append(i->second);
 105             s2.append(i->first + " = " + i->second);
 106         }
 107         return make_pair(s1.makeStringAndClear(), s2.makeStringAndClear());
 108     }
 109
 110 /*
 111     Whenever the attribute value contains special characters, such as '"' or ',' (without '')
 112     then the value will be enclosed in double quotes by the respective Windows or NSS function
 113     which we use to retrieve, for example, the subject name. If double quotes appear in the value then
 114     they are escaped with a double quote. This function removes the escape characters.
 115 */
 116 #ifdef _WIN32
 117 vector< pair< OUString, OUString> > parseDN(const OUString& rRawString)
 118 {
 119         vector< pair<OUString, OUString> > retVal;
 120         bool bInEscape = false;
 121         bool bInValue = false;
 122         bool bInType = true;
 123         sal_Int32 nTypeNameStart = 0;
 124         OUString sType;
 125         OUStringBuffer sbufValue;
 126         sal_Int32 length = rRawString.getLength();
 127
 128         for (sal_Int32 i = 0; i < length; i++)
 129         {
 130             sal_Unicode c = rRawString[i];
 131
 132             if (c == '=')
 133             {
 134                 if (! bInValue)
 135                 {
 136                     sType = rRawString.copy(nTypeNameStart, i - nTypeNameStart);
 137                     sType = sType.trim();
 138                     bInType = false;
 139                 }
 140                 else
 141                 {
 142                     sbufValue.append(c);
 143                 }
 144             }
 145             else if (c == '"')
 146             {
 147                 if (!bInEscape)
 148                 {
 149                     //If this is the quote is the first of the couple which enclose the
 150                     //whole value, because the value contains special characters
 151                     //then we just drop it. That is, this character must be followed by
 152                     //a character which is not '"'.
 153                     if ( i + 1 < length && rRawString[i+1] == '"')
 154                         bInEscape = true;
 155                     else
 156                         bInValue = !bInValue; //value is enclosed in " "
 157                 }
 158                 else
 159                 {
 160                     //This quote is escaped by a preceding quote and therefore is
 161                     //part of the value
 162                     sbufValue.append(c);
 163                     bInEscape = false;
 164                 }
 165             }
 166             else if (c == ',' || c == '+')
 167             {
 168                 //The comma separate the attribute value pairs.
 169                 //If the comma is not part of a value (the value would then be enclosed in '"'),
 170                 //then we have reached the end of the value
 171                 if (!bInValue)
 172                 {
 173                     OSL_ASSERT(!sType.isEmpty());
 174                     retVal.push_back(make_pair(sType, sbufValue.makeStringAndClear()));
 175                     sType.clear();
 176                     //The next char is the start of the new type
 177                     nTypeNameStart = i + 1;
 178                     bInType = true;
 179                 }
 180                 else
 181                 {
 182                     //The whole string is enclosed because it contains special characters.
 183                     //The enclosing '"' are not part of certificate but will be added by
 184                     //the function (Windows or NSS) which retrieves DN
 185                     sbufValue.append(c);
 186                 }
 187             }
 188             else
 189             {
 190                 if (!bInType)
 191                     sbufValue.append(c);
 192             }
 193         }
 194         if (sbufValue.getLength())
 195         {
 196             OSL_ASSERT(!sType.isEmpty());
 197             retVal.push_back(make_pair(sType, sbufValue.makeStringAndClear()));
 198         }
 199         return retVal;
 200     }
 201 #else
 202 vector< pair< OUString, OUString> > parseDN(const OUString& rRawString)
 203     {
 204         vector< pair<OUString, OUString> > retVal;
 205         //bInEscape == true means that the preceding character is an escape character
 206         bool bInEscape = false;
 207         bool bInValue = false;
 208         bool bInType = true;
 209         sal_Int32 nTypeNameStart = 0;
 210         OUString sType;
 211         OUStringBuffer sbufValue;
 212         sal_Int32 length = rRawString.getLength();
 213
 214         for (sal_Int32 i = 0; i < length; i++)
 215         {
 216             sal_Unicode c = rRawString[i];
 217
 218             if (c == '=')
 219             {
 220                 if (! bInValue)
 221                 {
 222                     sType = rRawString.copy(nTypeNameStart, i - nTypeNameStart);
 223                     sType = sType.trim();
 224                     bInType = false;
 225                 }
 226                 else
 227                 {
 228                     sbufValue.append(c);
 229                 }
 230             }
 231             else if (c == '\\')
 232             {
 233                 if (!bInEscape)
 234                 {
 235                     bInEscape = true;
 236                 }
 237                 else
 238                 { // bInEscape is true
 239                     sbufValue.append(c);
 240                     bInEscape = false;
 241                 }
 242             }
 243             else if (c == '"')
 244             {
 245                 //an unescaped '"' is either at the beginning or end of the value
 246                 if (!bInEscape)
 247                 {
 248                     if ( !bInValue)
 249                         bInValue = true;
 250                     else if (bInValue)
 251                         bInValue = false;
 252                 }
 253                 else
 254                 {
 255                     //This quote is escaped by a preceding quote and therefore is
 256                     //part of the value
 257                     sbufValue.append(c);
 258                     bInEscape = false;
 259                 }
 260             }
 261             else if (c == ',' || c == '+')
 262             {
 263                 //The comma separate the attribute value pairs.
 264                 //If the comma is not part of a value (the value would then be enclosed in '"'),
 265                 //then we have reached the end of the value
 266                 if (!bInValue)
 267                 {
 268                     OSL_ASSERT(!sType.isEmpty());
 269                     retVal.push_back(make_pair(sType, sbufValue.makeStringAndClear()));
 270                     sType.clear();
 271                     //The next char is the start of the new type
 272                     nTypeNameStart = i + 1;
 273                     bInType = true;
 274                 }
 275                 else
 276                 {
 277                     //The whole string is enclosed because it contains special characters.
 278                     //The enclosing '"' are not part of certificate but will be added by
 279                     //the function (Windows or NSS) which retrieves DN
 280                     sbufValue.append(c);
 281                 }
 282             }
 283             else
 284             {
 285                 if (!bInType)
 286                 {
 287                     sbufValue.append(c);
 288                     bInEscape = false;
 289                 }
 290             }
 291         }
 292         if (!sbufValue.isEmpty())
 293         {
 294             OSL_ASSERT(!sType.isEmpty());
 295             retVal.push_back(make_pair(sType, sbufValue.makeStringAndClear()));
 296         }
 297         return retVal;
 298     }
 299
 300 #endif
 301
 302     OUString GetContentPart( const OUString& _rRawString )
 303     {
 304         char const * aIDs[] = { "CN", "OU", "O", "E", nullptr };
 305         bool shouldBeParsed = false;
 306         int i = 0;
 307         while ( aIDs[i] )
 308         {
 309             if (_rRawString.startsWith(OUString::createFromAscii(aIDs[i++])))
 310             {
 311                 shouldBeParsed = true;
 312                 break;
 313             }
 314         }
 315
 316         if (!shouldBeParsed)
 317             return _rRawString;
 318
 319         OUString retVal;
 320         i = 0;
 321         vector< pair< OUString, OUString > > vecAttrValueOfDN = parseDN(_rRawString);
 322         while ( aIDs[i] )
 323         {
 324             OUString sPartId = OUString::createFromAscii( aIDs[i++] );
 325             typedef vector< pair < OUString, OUString > >::const_iterator CIT;
 326             for (CIT idn = vecAttrValueOfDN.begin(); idn != vecAttrValueOfDN.end(); ++idn)
 327             {
 328                 if (idn->first.equals(sPartId))
 329                 {
 330                     retVal = idn->second;
 331                     break;
 332                 }
 333             }
 334             if (!retVal.isEmpty())
 335                 break;
 336         }
 337         return retVal;
 338     }
 339
 340     OUString GetHexString( const css::uno::Sequence< sal_Int8 >& _rSeq, const char* _pSep, sal_uInt16 _nLineBreak )
 341     {
 342         const sal_Int8*         pSerNumSeq = _rSeq.getConstArray();
 343         int                     nCnt = _rSeq.getLength();
 344         OUStringBuffer          aStr;
 345         const char              pHexDigs[ 17 ] = "0123456789ABCDEF";
 346         char                    pBuffer[ 3 ] = "  ";
 347         sal_uInt8                   nNum;
 348         sal_uInt16                  nBreakStart = _nLineBreak? _nLineBreak : 1;
 349         sal_uInt16                  nBreak = nBreakStart;
 350         for( int i = 0 ; i < nCnt ; ++i )
 351         {
 352             nNum = sal_uInt8( pSerNumSeq[ i ] );
 353
 354             // exchange the buffer[0] and buffer[1], which make it consistent with Mozilla and Windows
 355             pBuffer[ 1 ] = pHexDigs[ nNum & 0x0F ];
 356             nNum >>= 4;
 357             pBuffer[ 0 ] = pHexDigs[ nNum ];
 358             aStr.appendAscii( pBuffer );
 359
 360             --nBreak;
 361             if( nBreak )
 362                 aStr.appendAscii( _pSep );
 363             else
 364             {
 365                 nBreak = nBreakStart;
 366                 aStr.append( '\n' );
 367             }
 368         }
 369
 370         return aStr.makeStringAndClear();
 371     }
 372 }
 373
 374 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */