Merge branch 'Keepass_Orig' + adapt to changes in KeePassLib. This introduced KDBX4 in Keepass2Android.

NOTE: seems like merging broke the capability to read KDBX<=3. Conflicts: src/KeePassLib2Android/Collections/AutoTypeConfig.cs src/KeePassLib2Android/Collections/ProtectedBinaryDictionary.cs src/KeePassLib2Android/Collections/ProtectedStringDictionary.cs src/KeePassLib2Android/Collections/PwObjectList.cs src/KeePassLib2Android/Collections/PwObjectPool.cs src/KeePassLib2Android/Collections/StringDictionaryEx.cs src/KeePassLib2Android/Cryptography/Cipher/CipherPool.cs src/KeePassLib2Android/Cryptography/Cipher/ICipherEngine.cs src/KeePassLib2Android/Cryptography/Cipher/Salsa20Cipher.cs src/KeePassLib2Android/Cryptography/Cipher/StandardAesEngine.cs src/KeePassLib2Android/Cryptography/CryptoRandom.cs src/KeePassLib2Android/Cryptography/CryptoRandomStream.cs src/KeePassLib2Android/Cryptography/HashingStreamEx.cs src/KeePassLib2Android/Cryptography/HmacOtp.cs src/KeePassLib2Android/Cryptography/PasswordGenerator/CharSetBasedGenerator.cs src/KeePassLib2Android/Cryptography/PasswordGenerator/CustomPwGenerator.cs src/KeePassLib2Android/Cryptography/PasswordGenerator/CustomPwGeneratorPool.cs src/KeePassLib2Android/Cryptography/PasswordGenerator/PatternBasedGenerator.cs src/KeePassLib2Android/Cryptography/PasswordGenerator/PwCharSet.cs src/KeePassLib2Android/Cryptography/PasswordGenerator/PwGenerator.cs src/KeePassLib2Android/Cryptography/PasswordGenerator/PwProfile.cs src/KeePassLib2Android/Cryptography/PopularPasswords.cs src/KeePassLib2Android/Cryptography/QualityEstimation.cs src/KeePassLib2Android/Cryptography/SelfTest.cs src/KeePassLib2Android/Delegates/Handlers.cs src/KeePassLib2Android/Interfaces/IDeepCloneable.cs src/KeePassLib2Android/Interfaces/IStatusLogger.cs src/KeePassLib2Android/Interfaces/IStructureItem.cs src/KeePassLib2Android/Interfaces/ITimeLogger.cs src/KeePassLib2Android/Interfaces/IUIOperations.cs src/KeePassLib2Android/Interfaces/IXmlSerializerEx.cs src/KeePassLib2Android/Keys/CompositeKey.cs src/KeePassLib2Android/Keys/IUserKey.cs src/KeePassLib2Android/Keys/KcpCustomKey.cs src/KeePassLib2Android/Keys/KcpKeyFile.cs src/KeePassLib2Android/Keys/KcpPassword.cs src/KeePassLib2Android/Keys/KcpUserAccount.cs src/KeePassLib2Android/Keys/KeyProvider.cs src/KeePassLib2Android/Keys/KeyProviderPool.cs src/KeePassLib2Android/Keys/KeyValidator.cs src/KeePassLib2Android/Keys/KeyValidatorPool.cs src/KeePassLib2Android/Keys/UserKeyType.cs src/KeePassLib2Android/Native/NativeLib.cs src/KeePassLib2Android/Native/NativeMethods.cs src/KeePassLib2Android/Properties/AssemblyInfo.cs src/KeePassLib2Android/PwCustomIcon.cs src/KeePassLib2Android/PwDatabase.cs src/KeePassLib2Android/PwDefs.cs src/KeePassLib2Android/PwDeletedObject.cs src/KeePassLib2Android/PwEntry.cs src/KeePassLib2Android/PwEnums.cs src/KeePassLib2Android/PwGroup.cs src/KeePassLib2Android/PwUuid.cs src/KeePassLib2Android/Resources/KLRes.Generated.cs src/KeePassLib2Android/Security/ProtectedBinary.cs src/KeePassLib2Android/Security/ProtectedString.cs src/KeePassLib2Android/Security/XorredBuffer.cs src/KeePassLib2Android/Serialization/BinaryReaderEx.cs src/KeePassLib2Android/Serialization/FileLock.cs src/KeePassLib2Android/Serialization/FileTransactionEx.cs src/KeePassLib2Android/Serialization/HashedBlockStream.cs src/KeePassLib2Android/Serialization/IOConnection.cs src/KeePassLib2Android/Serialization/IOConnectionInfo.cs src/KeePassLib2Android/Serialization/KdbxFile.Read.Streamed.cs src/KeePassLib2Android/Serialization/KdbxFile.Read.cs src/KeePassLib2Android/Serialization/KdbxFile.Write.cs src/KeePassLib2Android/Serialization/KdbxFile.cs src/KeePassLib2Android/Serialization/OldFormatException.cs src/KeePassLib2Android/Translation/KPControlCustomization.cs src/KeePassLib2Android/Translation/KPFormCustomization.cs src/KeePassLib2Android/Translation/KPStringTable.cs src/KeePassLib2Android/Translation/KPStringTableItem.cs src/KeePassLib2Android/Translation/KPTranslation.cs src/KeePassLib2Android/Translation/KPTranslationProperties.cs src/KeePassLib2Android/Utility/AppLogEx.cs src/KeePassLib2Android/Utility/GfxUtil.cs src/KeePassLib2Android/Utility/MemUtil.cs src/KeePassLib2Android/Utility/MessageService.cs src/KeePassLib2Android/Utility/StrUtil.cs src/KeePassLib2Android/Utility/TimeUtil.cs src/KeePassLib2Android/Utility/UrlUtil.cs
2016-08-31 06:55:53 +02:00
parent 4e1c53d5c9 a2f2e3d6f8
commit 2e8c76d0c4
73 changed files with 7914 additions and 1981 deletions
--- a/src/KeePassLib2Android/Utility/StrUtil.cs
+++ b/src/KeePassLib2Android/Utility/StrUtil.cs
@@ -1,8 +1,6 @@
 /*
  KeePass Password Safe - The Open-Source Password Manager
-  Copyright (C) 2003-2013 Dominik Reichl <dominik.reichl@t-online.de>
-  
-  Modified to be used with Mono for Android. Changes Copyright (C) 2013 Philipp Crocoll
+  Copyright (C) 2003-2016 Dominik Reichl <dominik.reichl@t-online.de>

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -22,19 +20,21 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Text;
-using System.Drawing;
-using System.IO;
-using System.Text.RegularExpressions;
-using System.Security.Cryptography;
-using System.Globalization;
 using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using System.Text.RegularExpressions;
+
+#if !KeePassUAP
+using System.Drawing;
+using System.Security.Cryptography;
+#endif

 using KeePassLib.Collections;
 using KeePassLib.Cryptography.PasswordGenerator;
 using KeePassLib.Native;
 using KeePassLib.Security;
-using KeePassLib.Resources;

 namespace KeePassLib.Utility
 {
@@ -221,8 +221,8 @@ namespace KeePassLib.Utility
 				List<StrEncodingInfo> l = new List<StrEncodingInfo>();

 				l.Add(new StrEncodingInfo(StrEncodingType.Default,
-#if KeePassRT
-					StrUtil.Utf8.WebName, StrUtil.Utf8, 1, null));
+#if KeePassUAP
+					"Unicode (UTF-8)", StrUtil.Utf8, 1, new byte[] { 0xEF, 0xBB, 0xBF }));
 #else
 #if !KeePassLibSD
 					Encoding.Default.EncodingName,
@@ -232,12 +232,11 @@ namespace KeePassLib.Utility
 					Encoding.Default,
 					(uint)Encoding.Default.GetBytes("a").Length, null));
 #endif
-#if !KeePassRT
+
 				l.Add(new StrEncodingInfo(StrEncodingType.Ascii,
 					"ASCII", Encoding.ASCII, 1, null));
 				l.Add(new StrEncodingInfo(StrEncodingType.Utf7,
 					"Unicode (UTF-7)", Encoding.UTF7, 1, null));
-#endif
 				l.Add(new StrEncodingInfo(StrEncodingType.Utf8,
 					"Unicode (UTF-8)", StrUtil.Utf8, 1, new byte[] { 0xEF, 0xBB, 0xBF }));
 				l.Add(new StrEncodingInfo(StrEncodingType.Utf16LE,
@@ -246,7 +245,8 @@ namespace KeePassLib.Utility
 				l.Add(new StrEncodingInfo(StrEncodingType.Utf16BE,
 					"Unicode (UTF-16 BE)", new UnicodeEncoding(true, false),
 					2, new byte[] { 0xFE, 0xFF }));
-#if (!KeePassLibSD && !KeePassRT)
+
+#if !KeePassLibSD
 				l.Add(new StrEncodingInfo(StrEncodingType.Utf32LE,
 					"Unicode (UTF-32 LE)", new UTF32Encoding(false, false),
 					4, new byte[] { 0xFF, 0xFE, 0x0, 0x0 }));
@@ -315,7 +315,7 @@ namespace KeePassLib.Utility
 			str = str.Replace("\'", @"&#39;");

 			str = NormalizeNewLines(str, false);
-			str = str.Replace("\n", @"<br />");
+			str = str.Replace("\n", @"<br />\n" );

 			return str;
 		}
@@ -358,9 +358,9 @@ namespace KeePassLib.Utility
 		}

 		/// <summary>
-		/// Split up a command-line into application and argument.
+		/// Split up a command line into application and argument.
 		/// </summary>
-		/// <param name="strCmdLine">Command-line to split.</param>
+		/// <param name="strCmdLine">Command line to split.</param>
 		/// <param name="strApp">Application path.</param>
 		/// <param name="strArgs">Arguments.</param>
 		public static void SplitCommandLine(string strCmdLine, out string strApp, out string strArgs)
@@ -487,53 +487,53 @@ namespace KeePassLib.Utility
 		public static string FormatException(Exception excp)
 		{
 			string strText = string.Empty;
-			
+			string NewLine = "\n";
 			if(excp.Message != null)
-				strText += excp.Message + MessageService.NewLine;
+				strText += excp.Message + NewLine;
 #if !KeePassLibSD
 			if(excp.Source != null)
-				strText += excp.Source + MessageService.NewLine;
+				strText += excp.Source + NewLine;
 #endif
 			if(excp.StackTrace != null)
-				strText += excp.StackTrace + MessageService.NewLine;
+				strText += excp.StackTrace + NewLine;
 #if !KeePassLibSD
-#if !KeePassRT
+#if !KeePassUAP
 			if(excp.TargetSite != null)
-				strText += excp.TargetSite.ToString() + MessageService.NewLine;
+				strText += excp.TargetSite.ToString() + NewLine;
 #endif

 			if(excp.Data != null)
 			{
-				strText += MessageService.NewLine;
+				strText += NewLine;
 				foreach(DictionaryEntry de in excp.Data)
 					strText += @"'" + de.Key + @"' -> '" + de.Value + @"'" +
-						MessageService.NewLine;
+						NewLine;
 			}
 #endif

 			if(excp.InnerException != null)
 			{
-				strText += MessageService.NewLine + "Inner:" + MessageService.NewLine;
+				strText += NewLine + "Inner:" + NewLine;
 				if(excp.InnerException.Message != null)
-					strText += excp.InnerException.Message + MessageService.NewLine;
+					strText += excp.InnerException.Message + NewLine;
 #if !KeePassLibSD
 				if(excp.InnerException.Source != null)
-					strText += excp.InnerException.Source + MessageService.NewLine;
+					strText += excp.InnerException.Source + NewLine;
 #endif
 				if(excp.InnerException.StackTrace != null)
-					strText += excp.InnerException.StackTrace + MessageService.NewLine;
+					strText += excp.InnerException.StackTrace + NewLine;
 #if !KeePassLibSD
-#if !KeePassRT
+#if !KeePassUAP
 				if(excp.InnerException.TargetSite != null)
 					strText += excp.InnerException.TargetSite.ToString();
 #endif

 				if(excp.InnerException.Data != null)
 				{
-					strText += MessageService.NewLine;
+					strText += NewLine;
 					foreach(DictionaryEntry de in excp.InnerException.Data)
 						strText += @"'" + de.Key + @"' -> '" + de.Value + @"'" +
-							MessageService.NewLine;
+							NewLine;
 				}
 #endif
 			}
@@ -760,7 +760,7 @@ namespace KeePassLib.Utility
 			return sb.ToString();
 		}

-		private static Regex m_rxNaturalSplit = null;
+		/* private static Regex g_rxNaturalSplit = null;
 		public static int CompareNaturally(string strX, string strY)
 		{
 			Debug.Assert(strX != null);
@@ -771,39 +771,31 @@ namespace KeePassLib.Utility
 			if(NativeMethods.SupportsStrCmpNaturally)
 				return NativeMethods.StrCmpNaturally(strX, strY);

-			strX = strX.ToLower(); // Case-insensitive comparison
-			strY = strY.ToLower();
+			if(g_rxNaturalSplit == null)
+				g_rxNaturalSplit = new Regex(@"([0-9]+)", RegexOptions.Compiled);

-			if(m_rxNaturalSplit == null)
-				m_rxNaturalSplit = new Regex(@"([0-9]+)",
-#if KeePassRT
-					RegexOptions.None);
-#else
-					RegexOptions.Compiled);
-#endif
+			string[] vPartsX = g_rxNaturalSplit.Split(strX);
+			string[] vPartsY = g_rxNaturalSplit.Split(strY);

-			string[] vPartsX = m_rxNaturalSplit.Split(strX);
-			string[] vPartsY = m_rxNaturalSplit.Split(strY);
-
-			for(int i = 0; i < Math.Min(vPartsX.Length, vPartsY.Length); ++i)
+			int n = Math.Min(vPartsX.Length, vPartsY.Length);
+			for(int i = 0; i < n; ++i)
 			{
 				string strPartX = vPartsX[i], strPartY = vPartsY[i];
 				int iPartCompare;

 #if KeePassLibSD
-				ulong uX = 0, uY = 0;
 				try
 				{
-					uX = ulong.Parse(strPartX);
-					uY = ulong.Parse(strPartY);
+					ulong uX = ulong.Parse(strPartX);
+					ulong uY = ulong.Parse(strPartY);
 					iPartCompare = uX.CompareTo(uY);
 				}
-				catch(Exception) { iPartCompare = strPartX.CompareTo(strPartY); }
+				catch(Exception) { iPartCompare = string.Compare(strPartX, strPartY, true); }
 #else
 				ulong uX, uY;
 				if(ulong.TryParse(strPartX, out uX) && ulong.TryParse(strPartY, out uY))
 					iPartCompare = uX.CompareTo(uY);
-				else iPartCompare = strPartX.CompareTo(strPartY);
+				else iPartCompare = string.Compare(strPartX, strPartY, true);
 #endif

 				if(iPartCompare != 0) return iPartCompare;
@@ -812,6 +804,106 @@ namespace KeePassLib.Utility
 			if(vPartsX.Length == vPartsY.Length) return 0;
 			if(vPartsX.Length < vPartsY.Length) return -1;
 			return 1;
+		} */
+
+		public static int CompareNaturally(string strX, string strY)
+		{
+			Debug.Assert(strX != null);
+			if(strX == null) throw new ArgumentNullException("strX");
+			Debug.Assert(strY != null);
+			if(strY == null) throw new ArgumentNullException("strY");
+
+			if(NativeMethods.SupportsStrCmpNaturally)
+				return NativeMethods.StrCmpNaturally(strX, strY);
+
+			int cX = strX.Length;
+			int cY = strY.Length;
+			if(cX == 0) return ((cY == 0) ? 0 : -1);
+			if(cY == 0) return 1;
+
+			char chFirstX = strX[0];
+			char chFirstY = strY[0];
+			bool bExpNum = ((chFirstX >= '0') && (chFirstX <= '9'));
+			bool bExpNumY = ((chFirstY >= '0') && (chFirstY <= '9'));
+			if(bExpNum != bExpNumY) return string.Compare(strX, strY, true);
+
+			int pX = 0;
+			int pY = 0;
+			while((pX < cX) && (pY < cY))
+			{
+				Debug.Assert(((strX[pX] >= '0') && (strX[pX] <= '9')) == bExpNum);
+				Debug.Assert(((strY[pY] >= '0') && (strY[pY] <= '9')) == bExpNum);
+
+				int pExclX = pX + 1;
+				while(pExclX < cX)
+				{
+					char ch = strX[pExclX];
+					bool bChNum = ((ch >= '0') && (ch <= '9'));
+					if(bChNum != bExpNum) break;
+					++pExclX;
+				}
+
+				int pExclY = pY + 1;
+				while(pExclY < cY)
+				{
+					char ch = strY[pExclY];
+					bool bChNum = ((ch >= '0') && (ch <= '9'));
+					if(bChNum != bExpNum) break;
+					++pExclY;
+				}
+
+				string strPartX = strX.Substring(pX, pExclX - pX);
+				string strPartY = strY.Substring(pY, pExclY - pY);
+
+				bool bStrCmp = true;
+				if(bExpNum)
+				{
+					// 2^64 - 1 = 18446744073709551615 has length 20
+					if((strPartX.Length <= 19) && (strPartY.Length <= 19))
+					{
+						ulong uX, uY;
+						if(ulong.TryParse(strPartX, out uX) && ulong.TryParse(strPartY, out uY))
+						{
+							if(uX < uY) return -1;
+							if(uX > uY) return 1;
+
+							bStrCmp = false;
+						}
+						else { Debug.Assert(false); }
+					}
+					else
+					{
+						double dX, dY;
+						if(double.TryParse(strPartX, out dX) && double.TryParse(strPartY, out dY))
+						{
+							if(dX < dY) return -1;
+							if(dX > dY) return 1;
+
+							bStrCmp = false;
+						}
+						else { Debug.Assert(false); }
+					}
+				}
+				if(bStrCmp)
+				{
+					int c = string.Compare(strPartX, strPartY, true);
+					if(c != 0) return c;
+				}
+
+				bExpNum = !bExpNum;
+				pX = pExclX;
+				pY = pExclY;
+			}
+
+			if(pX >= cX)
+			{
+				Debug.Assert(pX == cX);
+				if(pY >= cY) { Debug.Assert(pY == cY); return 0; }
+				return -1;
+			}
+
+			Debug.Assert(pY == cY);
+			return 1;
 		}

 		public static string RemoveAccelerator(string strMenuText)
@@ -835,6 +927,40 @@ namespace KeePassLib.Utility
 			return str;
 		}

+		public static string AddAccelerator(string strMenuText,
+			List<char> lAvailKeys)
+		{
+			if(strMenuText == null) { Debug.Assert(false); return null; }
+			if(lAvailKeys == null) { Debug.Assert(false); return strMenuText; }
+
+			int xa = -1, xs = 0;
+			for(int i = 0; i < strMenuText.Length; ++i)
+			{
+				char ch = strMenuText[i];
+
+#if KeePassLibSD
+				char chUpper = char.ToUpper(ch);
+#else
+				char chUpper = char.ToUpperInvariant(ch);
+#endif
+				xa = lAvailKeys.IndexOf(chUpper);
+				if(xa >= 0) { xs = i; break; }
+
+#if KeePassLibSD
+				char chLower = char.ToLower(ch);
+#else
+				char chLower = char.ToLowerInvariant(ch);
+#endif
+				xa = lAvailKeys.IndexOf(chLower);
+				if(xa >= 0) { xs = i; break; }
+			}
+
+			if(xa < 0) return strMenuText;
+
+			lAvailKeys.RemoveAt(xa);
+			return strMenuText.Insert(xs, @"&");
+		}
+
 		public static string EncodeMenuText(string strText)
 		{
 			if(strText == null) throw new ArgumentNullException("strText");
@@ -852,13 +978,12 @@ namespace KeePassLib.Utility
 		public static bool IsHexString(string str, bool bStrict)
 		{
 			if(str == null) throw new ArgumentNullException("str");
-			if(str.Length == 0) return true;

 			foreach(char ch in str)
 			{
 				if((ch >= '0') && (ch <= '9')) continue;
-				if((ch >= 'a') && (ch <= 'z')) continue;
-				if((ch >= 'A') && (ch <= 'Z')) continue;
+				if((ch >= 'a') && (ch <= 'f')) continue;
+				if((ch >= 'A') && (ch <= 'F')) continue;

 				if(bStrict) return false;

@@ -871,8 +996,31 @@ namespace KeePassLib.Utility
 			return true;
 		}

+		public static bool IsHexString(byte[] pbUtf8, bool bStrict)
+		{
+			if(pbUtf8 == null) throw new ArgumentNullException("pbUtf8");
+
+			for(int i = 0; i < pbUtf8.Length; ++i)
+			{
+				byte bt = pbUtf8[i];
+				if((bt >= (byte)'0') && (bt <= (byte)'9')) continue;
+				if((bt >= (byte)'a') && (bt <= (byte)'f')) continue;
+				if((bt >= (byte)'A') && (bt <= (byte)'F')) continue;
+
+				if(bStrict) return false;
+
+				if((bt == (byte)' ') || (bt == (byte)'\t') ||
+					(bt == (byte)'\r') || (bt == (byte)'\n'))
+					continue;
+
+				return false;
+			}
+
+			return true;
+		}
+
 #if !KeePassLibSD
-		private static readonly char[] m_vPatternPartsSep = new char[]{ '*' };
+		private static readonly char[] m_vPatternPartsSep = new char[] { '*' };
 		public static bool SimplePatternMatch(string strPattern, string strText,
 			StringComparison sc)
 		{
@@ -997,6 +1145,36 @@ namespace KeePassLib.Utility
 			}
 		}

+		public static string GetNewLineSeq(string str)
+		{
+			if(str == null) { Debug.Assert(false); return "\n"; }
+
+			int n = str.Length, nLf = 0, nCr = 0, nCrLf = 0;
+			char chLast = char.MinValue;
+			for(int i = 0; i < n; ++i)
+			{
+				char ch = str[i];
+
+				if(ch == '\r') ++nCr;
+				else if(ch == '\n')
+				{
+					++nLf;
+					if(chLast == '\r') ++nCrLf;
+				}
+
+				chLast = ch;
+			}
+
+			nCr -= nCrLf;
+			nLf -= nCrLf;
+
+			int nMax = Math.Max(nCrLf, Math.Max(nCr, nLf));
+			if(nMax == 0) return "\n";
+
+			if(nCrLf == nMax) return "\r\n";
+			return ((nLf == nMax) ? "\n" : "\r");
+		}
+
 		public static string AlphaNumericOnly(string str)
 		{
 			if(string.IsNullOrEmpty(str)) return str;
@@ -1074,37 +1252,44 @@ namespace KeePassLib.Utility

 		public static string VersionToString(ulong uVersion)
 		{
-			return VersionToString(uVersion, false);
+			return VersionToString(uVersion, 1U);
 		}

+		[Obsolete]
 		public static string VersionToString(ulong uVersion,
 			bool bEnsureAtLeastTwoComp)
 		{
-			string str = string.Empty;
-			bool bMultiComp = false;
+			return VersionToString(uVersion, (bEnsureAtLeastTwoComp ? 2U : 1U));
+		}
+
+		public static string VersionToString(ulong uVersion, uint uMinComp)
+		{
+			StringBuilder sb = new StringBuilder();
+			uint uComp = 0;

 			for(int i = 0; i < 4; ++i)
 			{
-				ushort us = (ushort)(uVersion & 0xFFFFUL);
+				if(uVersion == 0UL) break;

-				if((us != 0) || (str.Length > 0))
-				{
-					if(str.Length > 0)
-					{
-						str = "." + str;
-						bMultiComp = true;
-					}
+				ushort us = (ushort)(uVersion >> 48);

-					str = us.ToString(NumberFormatInfo.InvariantInfo) + str;
-				}
+				if(sb.Length > 0) sb.Append('.');

-				uVersion >>= 16;
+				sb.Append(us.ToString(NumberFormatInfo.InvariantInfo));
+				++uComp;
+
+				uVersion <<= 16;
 			}

-			if(bEnsureAtLeastTwoComp && !bMultiComp && (str.Length > 0))
-				str += ".0";
+			while(uComp < uMinComp)
+			{
+				if(sb.Length > 0) sb.Append('.');

-			return str;
+				sb.Append('0');
+				++uComp;
+			}
+
+			return sb.ToString();
 		}

 		private static readonly byte[] m_pbOptEnt = { 0xA5, 0x74, 0x2E, 0xEC };
@@ -1169,7 +1354,7 @@ namespace KeePassLib.Utility
 			return v;
 		}

-		private static readonly char[] m_vTagSep = new char[]{ ',', ';', ':' };
+		private static readonly char[] m_vTagSep = new char[] { ',', ';', ':' };
 		public static string TagsToString(List<string> vTags, bool bForDisplay)
 		{
 			if(vTags == null) throw new ArgumentNullException("vTags");
@@ -1222,7 +1407,7 @@ namespace KeePassLib.Utility
 			Array.Reverse(pb);
 			for(int i = 0; i < pb.Length; ++i) pb[i] = (byte)(pb[i] ^ 0x65);

-#if (!KeePassLibSD && !KeePassRT)
+#if (!KeePassLibSD && !KeePassUAP)
 			return Convert.ToBase64String(pb, Base64FormattingOptions.None);
 #else
 			return Convert.ToBase64String(pb);
@@ -1382,7 +1567,7 @@ namespace KeePassLib.Utility

 			if(strMimeType == null) strMimeType = "application/octet-stream";

-#if (!KeePassLibSD && !KeePassRT)
+#if (!KeePassLibSD && !KeePassUAP)
 			return ("data:" + strMimeType + ";base64," + Convert.ToBase64String(
 				pbData, Base64FormattingOptions.None));
 #else
@@ -1412,12 +1597,7 @@ namespace KeePassLib.Utility
 			if(bBase64) return Convert.FromBase64String(strData);

 			MemoryStream ms = new MemoryStream();
-
-#if KeePassRT
-			Encoding enc = StrUtil.Utf8;
-#else
 			Encoding enc = Encoding.ASCII;
-#endif

 			string[] v = strData.Split('%');
 			byte[] pb = enc.GetBytes(v[0]);