revert unintentional change

docs/README.md

@@ -11,10 +11,10 @@ Regular stable releases of Keepass2Android are available on [Google Play](https:
 Beta-releases can be obtained by opting in to the [Beta testing channel](https://play.google.com/apps/testing/keepass2android.keepass2android) or [Beta testing channel for Keepass2Android Offline](https://play.google.com/apps/testing/keepass2android.keepass2android_nonet).
 
 # How can I contribute?
-* Help to translate Keepass2Android into your language or improve translations at [our Crowdin page](http://crowdin.net/project/keepass2android)
+* Help to translate Keepass2Android into your language or improve translations at [our Crowdin page](https://crowdin.net/project/keepass2android)
 * Add features by [creating a plugin](How-to-create-a-plug-in_.md) or creating a pull request. You might want to contact me before you start working so I can coordinate efforts.
 * [Become a GitHub sponsor to boost 🚀 development](https://github.com/sponsors/PhilippC)
-* [Make a donation](http://philipp.crocoll.net/donate.php)
+* [Make a donation](https://philipp.crocoll.net/donate.php)
 
 # How do I learn more?
 Please see the [wiki](https://github.com/PhilippC/keepass2android/wiki/Documentation) for further information.

src/KeePassLib2Android/Cryptography/CryptoRandomStream.cs

@@ -1,6 +1,6 @@
 /*
   KeePass Password Safe - The Open-Source Password Manager
-  Copyright (C) 2003-2017 Dominik Reichl <dominik.reichl@t-online.de>
+  Copyright (C) 2003-2025 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
@@ -40,8 +40,8 @@ namespace KeePassLib.Cryptography
         Null = 0,
 
         /// <summary>
-		/// A variant of the ARCFour algorithm (RC4 incompatible).
-		/// </summary>
+        /// A variant of the ArcFour algorithm (RC4 incompatible).
+        /// Insecure; for backward compatibility only.
         /// </summary>
         ArcFourVariant = 1,
 
@@ -66,68 +66,72 @@ namespace KeePassLib.Cryptography
     /// </summary>
     public sealed class CryptoRandomStream : IDisposable
     {
-		private readonly CrsAlgorithm m_crsAlgorithm;
+        private readonly CrsAlgorithm m_alg;
+        private bool m_bDisposed = false;
 
-		private byte[] m_pbState = null;
+        private readonly byte[] m_pbKey = null;
+        private readonly byte[] m_pbIV = null;
+
+        private readonly ChaCha20Cipher m_chacha20 = null;
+        private readonly Salsa20Cipher m_salsa20 = null;
+
+        private readonly byte[] m_pbState = null;
         private byte m_i = 0;
         private byte m_j = 0;
 
-		private Salsa20Cipher m_salsa20 = null;
-		private ChaCha20Cipher m_chacha20 = null;
-
         /// <summary>
         /// Construct a new cryptographically secure random stream object.
         /// </summary>
-		/// <param name="genAlgorithm">Algorithm to use.</param>
-		/// <param name="pbKey">Initialization key. Must not be <c>null</c> and
-		/// must contain at least 1 byte.</param>
+        /// <param name="a">Algorithm to use.</param>
+        /// <param name="pbKey">Initialization key. Must not be <c>null</c>
+        /// and must contain at least 1 byte.</param>
         public CryptoRandomStream(CrsAlgorithm a, byte[] pbKey)
         {
-			if(pbKey == null) { Debug.Assert(false); throw new ArgumentNullException("pbKey"); }
-		/// <exception cref="System.ArgumentNullException">Thrown if the
+            if (pbKey == null) { Debug.Assert(false); throw new ArgumentNullException("pbKey"); }
+
             int cbKey = pbKey.Length;
-			if(cbKey <= 0)
+            if (cbKey <= 0)
             {
                 Debug.Assert(false); // Need at least one byte
                 throw new ArgumentOutOfRangeException("pbKey");
             }
-		/// <paramref name="pbKey" /> parameter is <c>null</c>.</exception>
-			m_crsAlgorithm = a;
-		/// <exception cref="System.ArgumentException">Thrown if the
-			if(a == CrsAlgorithm.ChaCha20)
+
+            m_alg = a;
+
+            if (a == CrsAlgorithm.ChaCha20)
             {
-				byte[] pbKey32 = new byte[32];
-				byte[] pbIV12 = new byte[12];
-		/// <paramref name="pbKey" /> parameter contains no bytes or the
-				using(SHA512Managed h = new SHA512Managed())
+                m_pbKey = new byte[32];
+                m_pbIV = new byte[12];
+
+                using (SHA512Managed h = new SHA512Managed())
                 {
                     byte[] pbHash = h.ComputeHash(pbKey);
-					Array.Copy(pbHash, pbKey32, 32);
-					Array.Copy(pbHash, 32, pbIV12, 0, 12);
+                    Array.Copy(pbHash, m_pbKey, 32);
+                    Array.Copy(pbHash, 32, m_pbIV, 0, 12);
                     MemUtil.ZeroByteArray(pbHash);
                 }
-		/// algorithm is unknown.</exception>
-				m_chacha20 = new ChaCha20Cipher(pbKey32, pbIV12, true);
+
+                m_chacha20 = new ChaCha20Cipher(m_pbKey, m_pbIV, true);
             }
-			else if(a == CrsAlgorithm.Salsa20)
+            else if (a == CrsAlgorithm.Salsa20)
             {
-				byte[] pbKey32 = CryptoUtil.HashSha256(pbKey);
-				byte[] pbIV8 = new byte[8] { 0xE8, 0x30, 0x09, 0x4B,
+                m_pbKey = CryptoUtil.HashSha256(pbKey);
+                m_pbIV = new byte[8] { 0xE8, 0x30, 0x09, 0x4B,
                     0x97, 0x20, 0x5D, 0x2A }; // Unique constant
 
-				m_salsa20 = new Salsa20Cipher(pbKey32, pbIV8);
+                m_salsa20 = new Salsa20Cipher(m_pbKey, m_pbIV);
             }
-			else if(a == CrsAlgorithm.ArcFourVariant)
+            else if (a == CrsAlgorithm.ArcFourVariant)
             {
                 // Fill the state linearly
                 m_pbState = new byte[256];
-				for(int w = 0; w < 256; ++w) m_pbState[w] = (byte)w;
+                for (int w = 0; w < 256; ++w) m_pbState[w] = (byte)w;
 
                 unchecked
                 {
                     byte j = 0, t;
                     int inxKey = 0;
-					for(int w = 0; w < 256; ++w) // Key setup
+                    for (int w = 0; w < 256; ++w) // Key setup
                     {
                         j += (byte)(m_pbState[w] + pbKey[inxKey]);
 
@@ -136,7 +140,7 @@ namespace KeePassLib.Cryptography
                         m_pbState[j] = t;
 
                         ++inxKey;
-						if(inxKey >= cbKey) inxKey = 0;
+                        if (inxKey >= cbKey) inxKey = 0;
                     }
                 }
 
@@ -157,19 +161,24 @@ namespace KeePassLib.Cryptography
 
         private void Dispose(bool disposing)
         {
-			if(disposing)
+            if (disposing)
             {
-				if(m_crsAlgorithm == CrsAlgorithm.ChaCha20)
+                if (m_alg == CrsAlgorithm.ChaCha20)
                     m_chacha20.Dispose();
-				else if(m_crsAlgorithm == CrsAlgorithm.Salsa20)
+                else if (m_alg == CrsAlgorithm.Salsa20)
                     m_salsa20.Dispose();
-				else if(m_crsAlgorithm == CrsAlgorithm.ArcFourVariant)
+                else if (m_alg == CrsAlgorithm.ArcFourVariant)
                 {
                     MemUtil.ZeroByteArray(m_pbState);
                     m_i = 0;
                     m_j = 0;
                 }
                 else { Debug.Assert(false); }
+
+                if (m_pbKey != null) MemUtil.ZeroByteArray(m_pbKey);
+                if (m_pbIV != null) MemUtil.ZeroByteArray(m_pbIV);
+
+                m_bDisposed = true;
             }
         }
 
@@ -180,23 +189,24 @@ namespace KeePassLib.Cryptography
         /// <returns>Returns <paramref name="uRequestedCount" /> random bytes.</returns>
         public byte[] GetRandomBytes(uint uRequestedCount)
         {
-			if(uRequestedCount == 0) return MemUtil.EmptyByteArray;
+            if (m_bDisposed) throw new ObjectDisposedException(null);
 
-			if(uRequestedCount > (uint)int.MaxValue)
+            if (uRequestedCount == 0) return MemUtil.EmptyByteArray;
+            if (uRequestedCount > (uint)int.MaxValue)
                 throw new ArgumentOutOfRangeException("uRequestedCount");
             int cb = (int)uRequestedCount;
 
             byte[] pbRet = new byte[cb];
 
-			if(m_crsAlgorithm == CrsAlgorithm.ChaCha20)
+            if (m_alg == CrsAlgorithm.ChaCha20)
                 m_chacha20.Encrypt(pbRet, 0, cb);
-			else if(m_crsAlgorithm == CrsAlgorithm.Salsa20)
+            else if (m_alg == CrsAlgorithm.Salsa20)
                 m_salsa20.Encrypt(pbRet, 0, cb);
-			else if(m_crsAlgorithm == CrsAlgorithm.ArcFourVariant)
+            else if (m_alg == CrsAlgorithm.ArcFourVariant)
             {
                 unchecked
                 {
-					for(int w = 0; w < cb; ++w)
+                    for (int w = 0; w < cb; ++w)
                     {
                         ++m_i;
                         m_j += m_pbState[m_i];
@@ -221,6 +231,25 @@ namespace KeePassLib.Cryptography
             return MemUtil.BytesToUInt64(pb);
         }
 
+        internal ulong GetRandomUInt64(ulong uMaxExcl)
+        {
+            if (uMaxExcl == 0) { Debug.Assert(false); throw new ArgumentOutOfRangeException("uMaxExcl"); }
+
+            ulong uGen, uRem;
+            do
+            {
+                uGen = GetRandomUInt64();
+                uRem = uGen % uMaxExcl;
+            }
+            while ((uGen - uRem) > (ulong.MaxValue - (uMaxExcl - 1UL)));
+            // This ensures that the last number of the block (i.e.
+            // (uGen - uRem) + (uMaxExcl - 1)) is generatable;
+            // for signed longs, overflow to negative number:
+            // while((uGen - uRem) + (uMaxExcl - 1) < 0);
+
+            return uRem;
+        }
+
 #if CRSBENCHMARK
 		public static string Benchmark()
 		{
@@ -237,21 +266,20 @@ namespace KeePassLib.Cryptography
 			return str;
 		}
 
-		private static int BenchTime(CrsAlgorithm cra, int nRounds, int nDataSize)
+		private static int BenchTime(CrsAlgorithm a, int nRounds, int cbData)
 		{
 			byte[] pbKey = new byte[4] { 0x00, 0x01, 0x02, 0x03 };
 
-			int nStart = Environment.TickCount;
+			int tStart = Environment.TickCount;
 			for(int i = 0; i < nRounds; ++i)
 			{
-				using(CryptoRandomStream c = new CryptoRandomStream(cra, pbKey))
+				using(CryptoRandomStream crs = new CryptoRandomStream(a, pbKey))
 				{
-					c.GetRandomBytes((uint)nDataSize);
+					crs.GetRandomBytes((uint)cbData);
 				}
 			}
-			int nEnd = Environment.TickCount;
 
-			return (nEnd - nStart);
+			return (Environment.TickCount - tStart);
 		}
 #endif
     }

src/KeePassLib2Android/Cryptography/PasswordGenerator/CharSetBasedGenerator.cs

@@ -1,65 +0,0 @@
-/*
-  KeePass Password Safe - The Open-Source Password Manager
-  Copyright (C) 2003-2017 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
-  the Free Software Foundation; either version 2 of the License, or
-  (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-*/
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Diagnostics;
-
-using KeePassLib.Security;
-using KeePassLib.Utility;
-
-namespace KeePassLib.Cryptography.PasswordGenerator
-{
-	internal static class CharSetBasedGenerator
-	{
-		internal static PwgError Generate(out ProtectedString psOut,
-			PwProfile pwProfile, CryptoRandomStream crsRandomSource)
-		{
-			psOut = ProtectedString.Empty;
-			if(pwProfile.Length == 0) return PwgError.Success;
-
-			PwCharSet pcs = new PwCharSet(pwProfile.CharSet.ToString());
-			char[] vGenerated = new char[pwProfile.Length];
-
-			PwGenerator.PrepareCharSet(pcs, pwProfile);
-
-			for(int nIndex = 0; nIndex < (int)pwProfile.Length; ++nIndex)
-			{
-				char ch = PwGenerator.GenerateCharacter(pwProfile, pcs,
-					crsRandomSource);
-
-				if(ch == char.MinValue)
-				{
-					MemUtil.ZeroArray<char>(vGenerated);
-					return PwgError.TooFewCharacters;
-				}
-
-				vGenerated[nIndex] = ch;
-			}
-
-			byte[] pbUtf8 = StrUtil.Utf8.GetBytes(vGenerated);
-			psOut = new ProtectedString(true, pbUtf8);
-			MemUtil.ZeroByteArray(pbUtf8);
-			MemUtil.ZeroArray<char>(vGenerated);
-
-			return PwgError.Success;
-		}
-	}
-}

src/KeePassLib2Android/Cryptography/PasswordGenerator/PatternBasedGenerator.cs

@@ -1,173 +0,0 @@
-/*
-  KeePass Password Safe - The Open-Source Password Manager
-  Copyright (C) 2003-2017 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
-  the Free Software Foundation; either version 2 of the License, or
-  (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-*/
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Diagnostics;
-
-using KeePassLib.Security;
-using KeePassLib.Utility;
-
-namespace KeePassLib.Cryptography.PasswordGenerator
-{
-	internal static class PatternBasedGenerator
-	{
-		internal static PwgError Generate(out ProtectedString psOut,
-			PwProfile pwProfile, CryptoRandomStream crsRandomSource)
-		{
-			psOut = ProtectedString.Empty;
-			LinkedList<char> vGenerated = new LinkedList<char>();
-			PwCharSet pcsCurrent = new PwCharSet();
-			PwCharSet pcsCustom = new PwCharSet();
-			PwCharSet pcsUsed = new PwCharSet();
-			bool bInCharSetDef = false;
-
-			string strPattern = ExpandPattern(pwProfile.Pattern);
-			if(strPattern.Length == 0) return PwgError.Success;
-
-			CharStream csStream = new CharStream(strPattern);
-			char ch = csStream.ReadChar();
-
-			while(ch != char.MinValue)
-			{
-				pcsCurrent.Clear();
-
-				bool bGenerateChar = false;
-
-				if(ch == '\\')
-				{
-					ch = csStream.ReadChar();
-					if(ch == char.MinValue) // Backslash at the end
-					{
-						vGenerated.AddLast('\\');
-						break;
-					}
-
-					if(bInCharSetDef) pcsCustom.Add(ch);
-					else
-					{
-						vGenerated.AddLast(ch);
-						pcsUsed.Add(ch);
-					}
-				}
-				else if(ch == '[')
-				{
-					pcsCustom.Clear();
-					bInCharSetDef = true;
-				}
-				else if(ch == ']')
-				{
-					pcsCurrent.Add(pcsCustom.ToString());
-
-					bInCharSetDef = false;
-					bGenerateChar = true;
-				}
-				else if(bInCharSetDef)
-				{
-					if(pcsCustom.AddCharSet(ch) == false)
-						pcsCustom.Add(ch);
-				}
-				else if(pcsCurrent.AddCharSet(ch) == false)
-				{
-					vGenerated.AddLast(ch);
-					pcsUsed.Add(ch);
-				}
-				else bGenerateChar = true;
-
-				if(bGenerateChar)
-				{
-					PwGenerator.PrepareCharSet(pcsCurrent, pwProfile);
-
-					if(pwProfile.NoRepeatingCharacters)
-						pcsCurrent.Remove(pcsUsed.ToString());
-
-					char chGen = PwGenerator.GenerateCharacter(pwProfile,
-						pcsCurrent, crsRandomSource);
-
-					if(chGen == char.MinValue) return PwgError.TooFewCharacters;
-
-					vGenerated.AddLast(chGen);
-					pcsUsed.Add(chGen);
-				}
-
-				ch = csStream.ReadChar();
-			}
-
-			if(vGenerated.Count == 0) return PwgError.Success;
-
-			char[] vArray = new char[vGenerated.Count];
-			vGenerated.CopyTo(vArray, 0);
-
-			if(pwProfile.PatternPermutePassword)
-				PwGenerator.ShufflePassword(vArray, crsRandomSource);
-
-			byte[] pbUtf8 = StrUtil.Utf8.GetBytes(vArray);
-			psOut = new ProtectedString(true, pbUtf8);
-			MemUtil.ZeroByteArray(pbUtf8);
-			MemUtil.ZeroArray<char>(vArray);
-			vGenerated.Clear();
-
-			return PwgError.Success;
-		}
-
-		private static string ExpandPattern(string strPattern)
-		{
-			Debug.Assert(strPattern != null); if(strPattern == null) return string.Empty;
-			string str = strPattern;
-
-			while(true)
-			{
-				int nOpen = FindFirstUnescapedChar(str, '{');
-				int nClose = FindFirstUnescapedChar(str, '}');
-
-				if((nOpen >= 0) && (nOpen < nClose))
-				{
-					string strCount = str.Substring(nOpen + 1, nClose - nOpen - 1);
-					str = str.Remove(nOpen, nClose - nOpen + 1);
-
-					uint uRepeat;
-					if(StrUtil.TryParseUInt(strCount, out uRepeat) && (nOpen >= 1))
-					{
-						if(uRepeat == 0)
-							str = str.Remove(nOpen - 1, 1);
-						else
-							str = str.Insert(nOpen, new string(str[nOpen - 1], (int)uRepeat - 1));
-					}
-				}
-				else break;
-			}
-
-			return str;
-		}
-
-		private static int FindFirstUnescapedChar(string str, char ch)
-		{
-			for(int i = 0; i < str.Length; ++i)
-			{
-				char chCur = str[i];
-
-				if(chCur == '\\') ++i; // Next is escaped, skip it
-				else if(chCur == ch) return i;
-			}
-
-			return -1;
-		}
-	}
-}

src/KeePassLib2Android/Cryptography/PasswordGenerator/PwCharSet.cs

@@ -1,6 +1,6 @@
 /*
   KeePass Password Safe - The Open-Source Password Manager
-  Copyright (C) 2003-2017 Dominik Reichl <dominik.reichl@t-online.de>
+  Copyright (C) 2003-2025 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
@@ -19,122 +19,81 @@
 
 using System;
 using System.Collections.Generic;
-using System.Text;
 using System.Diagnostics;
+using System.Text;
+
+using KeePassLib.Utility;
 
 namespace KeePassLib.Cryptography.PasswordGenerator
 {
-	public sealed class PwCharSet
+    public sealed class PwCharSet : IEquatable<PwCharSet>
     {
-		public const string UpperCase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-		public const string LowerCase = "abcdefghijklmnopqrstuvwxyz";
-		public const string Digits = "0123456789";
+        public static readonly string UpperCase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        public static readonly string LowerCase = "abcdefghijklmnopqrstuvwxyz";
+        public static readonly string Digits = "0123456789";
 
-		public const string UpperConsonants = "BCDFGHJKLMNPQRSTVWXYZ";
-		public const string LowerConsonants = "bcdfghjklmnpqrstvwxyz";
-		public const string UpperVowels = "AEIOU";
-		public const string LowerVowels = "aeiou";
+        public static readonly string UpperConsonants = "BCDFGHJKLMNPQRSTVWXYZ";
+        public static readonly string LowerConsonants = "bcdfghjklmnpqrstvwxyz";
+        public static readonly string UpperVowels = "AEIOU";
+        public static readonly string LowerVowels = "aeiou";
 
-		public const string Punctuation = @",.;:";
-		public const string Brackets = @"[]{}()<>";
+        public static readonly string Punctuation = ",.;:";
+        public static readonly string Brackets = @"[]{}()<>";
 
-		public const string PrintableAsciiSpecial = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
+        public static readonly string Special = "!\"#$%&'*+,./:;=?@\\^`|~";
+        public static readonly string PrintableAsciiSpecial = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
 
-		public const string UpperHex = "0123456789ABCDEF";
-		public const string LowerHex = "0123456789abcdef";
+        public static readonly string UpperHex = "0123456789ABCDEF";
+        public static readonly string LowerHex = "0123456789abcdef";
 
-		public const string Invalid = "\t\r\n";
-		public const string LookAlike = @"O0l1I|";
-
-		internal const string MenuAccels = PwCharSet.LowerCase + PwCharSet.Digits;
-
-		private const int CharTabSize = (0x10000 / 8);
-
-		private List<char> m_vChars = new List<char>();
-		private byte[] m_vTab = new byte[CharTabSize];
-
-		private static string m_strHighAnsi = null;
-		public static string HighAnsiChars
-		{
-			get
-			{
-				if(m_strHighAnsi == null) { new PwCharSet(); } // Create string
-				Debug.Assert(m_strHighAnsi != null);
-				return m_strHighAnsi;
-			}
-		}
-
-		private static string m_strSpecial = null;
-		public static string SpecialChars
-		{
-			get
-			{
-				if(m_strSpecial == null) { new PwCharSet(); } // Create string
-				Debug.Assert(m_strSpecial != null);
-				return m_strSpecial;
-			}
-		}
+        public static readonly string LookAlike = "O0Il1|";
 
         /// <summary>
-		/// Create a new, empty character set collection object.
+        /// Latin-1 Supplement except U+00A0 (NBSP) and U+00AD (SHY).
+        /// </summary>
+        public static readonly string Latin1S =
+            "\u00A1\u00A2\u00A3\u00A4\u00A5\u00A6\u00A7" +
+            "\u00A8\u00A9\u00AA\u00AB\u00AC\u00AE\u00AF" +
+            "\u00B0\u00B1\u00B2\u00B3\u00B4\u00B5\u00B6\u00B7" +
+            "\u00B8\u00B9\u00BA\u00BB\u00BC\u00BD\u00BE\u00BF" +
+            "\u00C0\u00C1\u00C2\u00C3\u00C4\u00C5\u00C6\u00C7" +
+            "\u00C8\u00C9\u00CA\u00CB\u00CC\u00CD\u00CE\u00CF" +
+            "\u00D0\u00D1\u00D2\u00D3\u00D4\u00D5\u00D6\u00D7" +
+            "\u00D8\u00D9\u00DA\u00DB\u00DC\u00DD\u00DE\u00DF" +
+            "\u00E0\u00E1\u00E2\u00E3\u00E4\u00E5\u00E6\u00E7" +
+            "\u00E8\u00E9\u00EA\u00EB\u00EC\u00ED\u00EE\u00EF" +
+            "\u00F0\u00F1\u00F2\u00F3\u00F4\u00F5\u00F6\u00F7" +
+            "\u00F8\u00F9\u00FA\u00FB\u00FC\u00FD\u00FE\u00FF";
+
+        // internal static readonly string MenuAccels = PwCharSet.LowerCase + PwCharSet.Digits;
+
+        [Obsolete]
+        public static string SpecialChars { get { return PwCharSet.Special; } }
+        [Obsolete]
+        public static string HighAnsiChars { get { return PwCharSet.Latin1S; } }
+
+        private readonly List<char> m_lChars = new List<char>();
+        private readonly byte[] m_vTab = new byte[0x10000 / 8];
+
+        /// <summary>
+        /// Create a new, empty character set.
         /// </summary>
         public PwCharSet()
         {
-			Initialize(true);
+            Debug.Assert(PwCharSet.Latin1S.Length == (16 * 6 - 2));
         }
 
         public PwCharSet(string strCharSet)
         {
-			Initialize(true);
             Add(strCharSet);
         }
 
-		private PwCharSet(bool bFullInitialize)
-		{
-			Initialize(bFullInitialize);
-		}
-
-		private void Initialize(bool bFullInitialize)
-		{
-			Clear();
-
-			if(!bFullInitialize) return;
-
-			if(m_strHighAnsi == null)
-			{
-				StringBuilder sbHighAnsi = new StringBuilder();
-				// [U+0080, U+009F] are C1 control characters,
-				// U+00A0 is non-breaking space
-				for(char ch = '\u00A1'; ch <= '\u00AC'; ++ch)
-					sbHighAnsi.Append(ch);
-				// U+00AD is soft hyphen (format character)
-				for(char ch = '\u00AE'; ch < '\u00FF'; ++ch)
-					sbHighAnsi.Append(ch);
-				sbHighAnsi.Append('\u00FF');
-
-				m_strHighAnsi = sbHighAnsi.ToString();
-			}
-
-			if(m_strSpecial == null)
-			{
-				PwCharSet pcs = new PwCharSet(false);
-				pcs.AddRange('!', '/');
-				pcs.AddRange(':', '@');
-				pcs.AddRange('[', '`');
-				pcs.Add(@"|~");
-				pcs.Remove(@"-_ ");
-				pcs.Remove(PwCharSet.Brackets);
-
-				m_strSpecial = pcs.ToString();
-			}
-		}
-
         /// <summary>
         /// Number of characters in this set.
         /// </summary>
         public uint Size
         {
-			get { return (uint)m_vChars.Count; }
+            get { return (uint)m_lChars.Count; }
         }
 
         /// <summary>
@@ -147,19 +106,39 @@ namespace KeePassLib.Cryptography.PasswordGenerator
         {
             get
             {
-				if(uPos >= (uint)m_vChars.Count)
+                if (uPos >= (uint)m_lChars.Count)
                     throw new ArgumentOutOfRangeException("uPos");
 
-				return m_vChars[(int)uPos];
+                return m_lChars[(int)uPos];
             }
         }
 
+        public bool Equals(PwCharSet other)
+        {
+            if (object.ReferenceEquals(other, this)) return true;
+            if (object.ReferenceEquals(other, null)) return false;
+
+            if (m_lChars.Count != other.m_lChars.Count) return false;
+
+            return MemUtil.ArraysEqual(m_vTab, other.m_vTab);
+        }
+
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as PwCharSet);
+        }
+
+        public override int GetHashCode()
+        {
+            return (int)MemUtil.Hash32(m_vTab, 0, m_vTab.Length);
+        }
+
         /// <summary>
         /// Remove all characters from this set.
         /// </summary>
         public void Clear()
         {
-			m_vChars.Clear();
+            m_lChars.Clear();
             Array.Clear(m_vTab, 0, m_vTab.Length);
         }
 
@@ -171,11 +150,11 @@ namespace KeePassLib.Cryptography.PasswordGenerator
         public bool Contains(string strCharacters)
         {
             Debug.Assert(strCharacters != null);
-			if(strCharacters == null) throw new ArgumentNullException("strCharacters");
+            if (strCharacters == null) throw new ArgumentNullException("strCharacters");
 
-			foreach(char ch in strCharacters)
+            foreach (char ch in strCharacters)
             {
-				if(!Contains(ch)) return false;
+                if (!Contains(ch)) return false;
             }
 
             return true;
@@ -187,11 +166,11 @@ namespace KeePassLib.Cryptography.PasswordGenerator
         /// <param name="ch">Character to add.</param>
         public void Add(char ch)
         {
-			if(ch == char.MinValue) { Debug.Assert(false); return; }
+            if (ch == char.MinValue) { Debug.Assert(false); return; }
 
-			if(!Contains(ch))
+            if (!Contains(ch))
             {
-				m_vChars.Add(ch);
+                m_lChars.Add(ch);
                 m_vTab[ch / 8] |= (byte)(1 << (ch % 8));
             }
         }
@@ -203,11 +182,9 @@ namespace KeePassLib.Cryptography.PasswordGenerator
         public void Add(string strCharSet)
         {
             Debug.Assert(strCharSet != null);
-			if(strCharSet == null) throw new ArgumentNullException("strCharSet");
+            if (strCharSet == null) throw new ArgumentNullException("strCharSet");
 
-			m_vChars.Capacity = m_vChars.Count + strCharSet.Length;
-
-			foreach(char ch in strCharSet)
+            foreach (char ch in strCharSet)
                 Add(ch);
         }
 
@@ -226,9 +203,7 @@ namespace KeePassLib.Cryptography.PasswordGenerator
 
         public void AddRange(char chMin, char chMax)
         {
-			m_vChars.Capacity = m_vChars.Count + (chMax - chMin) + 1;
-
-			for(char ch = chMin; ch < chMax; ++ch)
+            for (char ch = chMin; ch < chMax; ++ch)
                 Add(ch);
 
             Add(chMax);
@@ -238,14 +213,16 @@ namespace KeePassLib.Cryptography.PasswordGenerator
         {
             bool bResult = true;
 
-			switch(chCharSetIdentifier)
+            switch (chCharSetIdentifier)
             {
                 case 'a': Add(PwCharSet.LowerCase, PwCharSet.Digits); break;
-				case 'A': Add(PwCharSet.LowerCase, PwCharSet.UpperCase,
+                case 'A':
+                    Add(PwCharSet.LowerCase, PwCharSet.UpperCase,
                     PwCharSet.Digits); break;
                 case 'U': Add(PwCharSet.UpperCase, PwCharSet.Digits); break;
                 case 'c': Add(PwCharSet.LowerConsonants); break;
-				case 'C': Add(PwCharSet.LowerConsonants,
+                case 'C':
+                    Add(PwCharSet.LowerConsonants,
                     PwCharSet.UpperConsonants); break;
                 case 'z': Add(PwCharSet.UpperConsonants); break;
                 case 'd': Add(PwCharSet.Digits); break; // Digit
@@ -257,12 +234,13 @@ namespace KeePassLib.Cryptography.PasswordGenerator
                 case 'p': Add(PwCharSet.Punctuation); break;
                 case 'b': Add(PwCharSet.Brackets); break;
                 case 's': Add(PwCharSet.PrintableAsciiSpecial); break;
-				case 'S': Add(PwCharSet.UpperCase, PwCharSet.LowerCase);
+                case 'S':
+                    Add(PwCharSet.UpperCase, PwCharSet.LowerCase);
                     Add(PwCharSet.Digits, PwCharSet.PrintableAsciiSpecial); break;
                 case 'v': Add(PwCharSet.LowerVowels); break;
                 case 'V': Add(PwCharSet.LowerVowels, PwCharSet.UpperVowels); break;
                 case 'Z': Add(PwCharSet.UpperVowels); break;
-				case 'x': Add(m_strHighAnsi); break;
+                case 'x': Add(PwCharSet.Latin1S); break;
                 default: bResult = false; break;
             }
 
@@ -272,18 +250,18 @@ namespace KeePassLib.Cryptography.PasswordGenerator
         public bool Remove(char ch)
         {
             m_vTab[ch / 8] &= (byte)(~(1 << (ch % 8)));
-			return m_vChars.Remove(ch);
+            return m_lChars.Remove(ch);
         }
 
         public bool Remove(string strCharacters)
         {
             Debug.Assert(strCharacters != null);
-			if(strCharacters == null) throw new ArgumentNullException("strCharacters");
+            if (strCharacters == null) throw new ArgumentNullException("strCharacters");
 
             bool bResult = true;
-			foreach(char ch in strCharacters)
+            foreach (char ch in strCharacters)
             {
-				if(!Remove(ch)) bResult = false;
+                if (!Remove(ch)) bResult = false;
             }
 
             return bResult;
@@ -292,9 +270,9 @@ namespace KeePassLib.Cryptography.PasswordGenerator
         public bool RemoveIfAllExist(string strCharacters)
         {
             Debug.Assert(strCharacters != null);
-			if(strCharacters == null) throw new ArgumentNullException("strCharacters");
+            if (strCharacters == null) throw new ArgumentNullException("strCharacters");
 
-			if(!Contains(strCharacters))
+            if (!Contains(strCharacters))
                 return false;
 
             return Remove(strCharacters);
@@ -306,8 +284,8 @@ namespace KeePassLib.Cryptography.PasswordGenerator
         /// <returns>String containing all character set characters.</returns>
         public override string ToString()
         {
-			StringBuilder sb = new StringBuilder();
-			foreach(char ch in m_vChars)
+            StringBuilder sb = new StringBuilder(m_lChars.Count);
+            foreach (char ch in m_lChars)
                 sb.Append(ch);
 
             return sb.ToString();
@@ -320,32 +298,32 @@ namespace KeePassLib.Cryptography.PasswordGenerator
             sb.Append(RemoveIfAllExist(PwCharSet.UpperCase) ? 'U' : '_');
             sb.Append(RemoveIfAllExist(PwCharSet.LowerCase) ? 'L' : '_');
             sb.Append(RemoveIfAllExist(PwCharSet.Digits) ? 'D' : '_');
-			sb.Append(RemoveIfAllExist(m_strSpecial) ? 'S' : '_');
+            sb.Append(RemoveIfAllExist(PwCharSet.Special) ? 'S' : '_');
             sb.Append(RemoveIfAllExist(PwCharSet.Punctuation) ? 'P' : '_');
-			sb.Append(RemoveIfAllExist(@"-") ? 'm' : '_');
-			sb.Append(RemoveIfAllExist(@"_") ? 'u' : '_');
-			sb.Append(RemoveIfAllExist(@" ") ? 's' : '_');
+            sb.Append(RemoveIfAllExist("-") ? 'm' : '_');
+            sb.Append(RemoveIfAllExist("_") ? 'u' : '_');
+            sb.Append(RemoveIfAllExist(" ") ? 's' : '_');
             sb.Append(RemoveIfAllExist(PwCharSet.Brackets) ? 'B' : '_');
-			sb.Append(RemoveIfAllExist(m_strHighAnsi) ? 'H' : '_');
+            sb.Append(RemoveIfAllExist(PwCharSet.Latin1S) ? 'H' : '_');
 
             return sb.ToString();
         }
 
         public void UnpackCharRanges(string strRanges)
         {
-			if(strRanges == null) { Debug.Assert(false); return; }
-			if(strRanges.Length < 10) { Debug.Assert(false); return; }
+            if (strRanges == null) { Debug.Assert(false); return; }
+            if (strRanges.Length < 10) { Debug.Assert(false); return; }
 
-			if(strRanges[0] != '_') Add(PwCharSet.UpperCase);
-			if(strRanges[1] != '_') Add(PwCharSet.LowerCase);
-			if(strRanges[2] != '_') Add(PwCharSet.Digits);
-			if(strRanges[3] != '_') Add(m_strSpecial);
-			if(strRanges[4] != '_') Add(PwCharSet.Punctuation);
-			if(strRanges[5] != '_') Add('-');
-			if(strRanges[6] != '_') Add('_');
-			if(strRanges[7] != '_') Add(' ');
-			if(strRanges[8] != '_') Add(PwCharSet.Brackets);
-			if(strRanges[9] != '_') Add(m_strHighAnsi);
+            if (strRanges[0] != '_') Add(PwCharSet.UpperCase);
+            if (strRanges[1] != '_') Add(PwCharSet.LowerCase);
+            if (strRanges[2] != '_') Add(PwCharSet.Digits);
+            if (strRanges[3] != '_') Add(PwCharSet.Special);
+            if (strRanges[4] != '_') Add(PwCharSet.Punctuation);
+            if (strRanges[5] != '_') Add('-');
+            if (strRanges[6] != '_') Add('_');
+            if (strRanges[7] != '_') Add(' ');
+            if (strRanges[8] != '_') Add(PwCharSet.Brackets);
+            if (strRanges[9] != '_') Add(PwCharSet.Latin1S);
         }
     }
 }

src/KeePassLib2Android/Cryptography/PasswordGenerator/PwGenerator.cs

@@ -1,6 +1,6 @@
 /*
   KeePass Password Safe - The Open-Source Password Manager
-  Copyright (C) 2003-2016 Dominik Reichl <dominik.reichl@t-online.de>
+  Copyright (C) 2003-2025 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
@@ -20,9 +20,13 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Security.Cryptography;
 using System.Text;
 
+#if !KeePassUAP
+using System.Security.Cryptography;
+#endif
+
+using KeePassLib.Resources;
 using KeePassLib.Security;
 using KeePassLib.Utility;
 
@@ -33,95 +37,78 @@ namespace KeePassLib.Cryptography.PasswordGenerator
         Success = 0,
         Unknown = 1,
         TooFewCharacters = 2,
-		UnknownAlgorithm = 3
+        UnknownAlgorithm = 3,
+        InvalidCharSet = 4,
+        InvalidPattern = 5
     }
 
     /// <summary>
-	/// Utility functions for generating random passwords.
+    /// Password generator.
     /// </summary>
     public static class PwGenerator
     {
-		public static PwgError Generate(out ProtectedString psOut,
-			PwProfile pwProfile, byte[] pbUserEntropy,
-			CustomPwGeneratorPool pwAlgorithmPool)
+
+        private static CryptoRandomStream CreateRandomStream(byte[] pbAdditionalEntropy,
+            out byte[] pbKey)
         {
-			Debug.Assert(pwProfile != null);
-			if (pwProfile == null) throw new ArgumentNullException("pwProfile");
-
-			CryptoRandomStream crs = CreateCryptoStream(pbUserEntropy);
-			PwgError e = PwgError.Unknown;
-
-			if (pwProfile.GeneratorType == PasswordGeneratorType.CharSet)
-				e = CharSetBasedGenerator.Generate(out psOut, pwProfile, crs);
-			else if (pwProfile.GeneratorType == PasswordGeneratorType.Pattern)
-				e = PatternBasedGenerator.Generate(out psOut, pwProfile, crs);
-			else if (pwProfile.GeneratorType == PasswordGeneratorType.Custom)
-				e = GenerateCustom(out psOut, pwProfile, crs, pwAlgorithmPool);
-			else { Debug.Assert(false); psOut = ProtectedString.Empty; }
-
-			return e;
-		}
-
-		private static CryptoRandomStream CreateCryptoStream(byte[] pbAdditionalEntropy)
-		{
-			byte[] pbKey = CryptoRandom.Instance.GetRandomBytes(128);
+            pbKey = CryptoRandom.Instance.GetRandomBytes(128);
 
             // Mix in additional entropy
             Debug.Assert(pbKey.Length >= 64);
-			if ((pbAdditionalEntropy != null) && (pbAdditionalEntropy.Length > 0))
+            if ((pbAdditionalEntropy != null) && (pbAdditionalEntropy.Length != 0))
             {
                 using (SHA512Managed h = new SHA512Managed())
                 {
                     byte[] pbHash = h.ComputeHash(pbAdditionalEntropy);
                     MemUtil.XorArray(pbHash, 0, pbKey, 0, pbHash.Length);
+                    MemUtil.ZeroByteArray(pbHash);
                 }
             }
 
             return new CryptoRandomStream(CrsAlgorithm.ChaCha20, pbKey);
         }
 
-		internal static char GenerateCharacter(PwProfile pwProfile,
-			PwCharSet pwCharSet, CryptoRandomStream crsRandomSource)
+        internal static char GenerateCharacter(PwCharSet pwCharSet,
+            CryptoRandomStream crsRandomSource)
         {
-			if (pwCharSet.Size == 0) return char.MinValue;
+            uint cc = pwCharSet.Size;
+            if (cc == 0) return char.MinValue;
 
-			ulong uIndex = crsRandomSource.GetRandomUInt64();
-			uIndex %= (ulong)pwCharSet.Size;
-
-			char ch = pwCharSet[(uint)uIndex];
-
-			if (pwProfile.NoRepeatingCharacters)
-				pwCharSet.Remove(ch);
-
-			return ch;
+            uint i = (uint)crsRandomSource.GetRandomUInt64(cc);
+            return pwCharSet[i];
         }
 
-		internal static void PrepareCharSet(PwCharSet pwCharSet, PwProfile pwProfile)
+        internal static bool PrepareCharSet(PwCharSet pwCharSet, PwProfile pwProfile)
         {
-			pwCharSet.Remove(PwCharSet.Invalid);
+            uint cc = pwCharSet.Size;
+            for (uint i = 0; i < cc; ++i)
+            {
+                char ch = pwCharSet[i];
+                if ((ch == char.MinValue) || (ch == '\t') || (ch == '\r') ||
+                    (ch == '\n') || char.IsSurrogate(ch))
+                    return false;
+            }
 
             if (pwProfile.ExcludeLookAlike) pwCharSet.Remove(PwCharSet.LookAlike);
 
-			if (pwProfile.ExcludeCharacters.Length > 0)
+            if (!string.IsNullOrEmpty(pwProfile.ExcludeCharacters))
                 pwCharSet.Remove(pwProfile.ExcludeCharacters);
+
+            return true;
         }
 
-		internal static void ShufflePassword(char[] pPassword,
-			CryptoRandomStream crsRandomSource)
+        internal static void Shuffle(char[] v, CryptoRandomStream crsRandomSource)
         {
-			Debug.Assert(pPassword != null); if (pPassword == null) return;
-			Debug.Assert(crsRandomSource != null); if (crsRandomSource == null) return;
+            if (v == null) { Debug.Assert(false); return; }
+            if (crsRandomSource == null) { Debug.Assert(false); return; }
 
-			if (pPassword.Length <= 1) return; // Nothing to shuffle
-
-			for (int nSelect = 0; nSelect < pPassword.Length; ++nSelect)
+            for (int i = v.Length - 1; i >= 1; --i)
             {
-				ulong uRandomIndex = crsRandomSource.GetRandomUInt64();
-				uRandomIndex %= (ulong)(pPassword.Length - nSelect);
+                int j = (int)crsRandomSource.GetRandomUInt64((ulong)(i + 1));
 
-				char chTemp = pPassword[nSelect];
-				pPassword[nSelect] = pPassword[nSelect + (int)uRandomIndex];
-				pPassword[nSelect + (int)uRandomIndex] = chTemp;
+                char t = v[i];
+                v[i] = v[j];
+                v[j] = t;
             }
         }
 
@@ -135,7 +122,7 @@ namespace KeePassLib.Cryptography.PasswordGenerator
             if (pwAlgorithmPool == null) return PwgError.UnknownAlgorithm;
 
             string strID = pwProfile.CustomAlgorithmUuid;
-			if (string.IsNullOrEmpty(strID)) { Debug.Assert(false); return PwgError.UnknownAlgorithm; }
+            if (string.IsNullOrEmpty(strID)) return PwgError.UnknownAlgorithm;
 
             byte[] pbUuid = Convert.FromBase64String(strID);
             PwUuid uuid = new PwUuid(pbUuid);
@@ -148,5 +135,57 @@ namespace KeePassLib.Cryptography.PasswordGenerator
             psOut = pwd;
             return PwgError.Success;
         }
+
+        internal static string ErrorToString(PwgError e, bool bHeader)
+        {
+            if (e == PwgError.Success) { Debug.Assert(false); return string.Empty; }
+            if ((e == PwgError.Unknown) && bHeader) return KLRes.PwGenFailed;
+
+            string str = KLRes.UnknownError;
+            switch (e)
+            {
+                // case PwgError.Success:
+                //	break;
+
+                case PwgError.Unknown:
+                    break;
+
+                case PwgError.TooFewCharacters:
+                    str = KLRes.CharSetTooFewChars;
+                    break;
+
+                case PwgError.UnknownAlgorithm:
+                    str = KLRes.AlgorithmUnknown;
+                    break;
+
+                case PwgError.InvalidCharSet:
+                    str = KLRes.CharSetInvalid;
+                    break;
+
+                case PwgError.InvalidPattern:
+                    str = KLRes.PatternInvalid;
+                    break;
+
+                default:
+                    Debug.Assert(false);
+                    break;
+            }
+
+            if (bHeader)
+                str = KLRes.PwGenFailed + MessageService.NewParagraph + str;
+
+            return str;
+        }
+
+        internal static string ErrorToString(Exception ex, bool bHeader)
+        {
+            string str = ((ex == null) ? KLRes.UnknownError :
+                StrUtil.FormatException(ex));
+
+            if (bHeader)
+                str = KLRes.PwGenFailed + MessageService.NewParagraph + str;
+
+            return str;
+        }
     }
 }

src/KeePassLib2Android/Cryptography/PopularPasswords.cs

@@ -1,6 +1,6 @@
 /*
   KeePass Password Safe - The Open-Source Password Manager
-  Copyright (C) 2003-2017 Dominik Reichl <dominik.reichl@t-online.de>
+  Copyright (C) 2003-2025 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
@@ -19,8 +19,8 @@
 
 using System;
 using System.Collections.Generic;
-using System.Text;
 using System.Diagnostics;
+using System.Text;
 
 using KeePassLib.Utility;
 
@@ -28,17 +28,19 @@ namespace KeePassLib.Cryptography
 {
     public static class PopularPasswords
     {
-		private static Dictionary<int, Dictionary<string, bool>> m_dicts =
-			new Dictionary<int, Dictionary<string, bool>>();
+        private static readonly Dictionary<int, Dictionary<char[], bool>> g_dicts =
+            new Dictionary<int, Dictionary<char[], bool>>();
 
         internal static int MaxLength
         {
             get
             {
+                Debug.Assert(g_dicts.Count > 0); // Should be initialized
+
                 int iMaxLen = 0;
-				foreach(int iLen in m_dicts.Keys)
+                foreach (int iLen in g_dicts.Keys)
                 {
-					if(iLen > iMaxLen) iMaxLen = iLen;
+                    if (iLen > iMaxLen) iMaxLen = iLen;
                 }
 
                 return iMaxLen;
@@ -47,8 +49,8 @@ namespace KeePassLib.Cryptography
 
         internal static bool ContainsLength(int nLength)
         {
-			Dictionary<string, bool> dDummy;
-			return m_dicts.TryGetValue(nLength, out dDummy);
+            Dictionary<char[], bool> dDummy;
+            return g_dicts.TryGetValue(nLength, out dDummy);
         }
 
         public static bool IsPopularPassword(char[] vPassword)
@@ -59,74 +61,73 @@ namespace KeePassLib.Cryptography
 
         public static bool IsPopularPassword(char[] vPassword, out ulong uDictSize)
         {
-			if(vPassword == null) throw new ArgumentNullException("vPassword");
-			if(vPassword.Length == 0) { uDictSize = 0; return false; }
+            if (vPassword == null) throw new ArgumentNullException("vPassword");
+            if (vPassword.Length == 0) { uDictSize = 0; return false; }
 
-			string str = new string(vPassword);
+#if DEBUG
+            Array.ForEach(vPassword, ch => Debug.Assert(ch == char.ToLower(ch)));
+#endif
 
-			try { return IsPopularPasswordPriv(str, out uDictSize); }
-			catch(Exception) { Debug.Assert(false); }
+            try { return IsPopularPasswordPriv(vPassword, out uDictSize); }
+            catch (Exception) { Debug.Assert(false); }
 
             uDictSize = 0;
             return false;
         }
 
-		private static bool IsPopularPasswordPriv(string str, out ulong uDictSize)
+        private static bool IsPopularPasswordPriv(char[] vPassword, out ulong uDictSize)
         {
-			Debug.Assert(m_dicts.Count > 0); // Should be initialized with data
+            Debug.Assert(g_dicts.Count > 0); // Should be initialized with data
 
-			Dictionary<string, bool> d;
-			if(!m_dicts.TryGetValue(str.Length, out d))
+            Dictionary<char[], bool> d;
+            if (!g_dicts.TryGetValue(vPassword.Length, out d))
             {
                 uDictSize = 0;
                 return false;
             }
 
             uDictSize = (ulong)d.Count;
-			return d.ContainsKey(str);
+            return d.ContainsKey(vPassword);
         }
 
         public static void Add(byte[] pbData, bool bGZipped)
         {
             try
             {
-				if(bGZipped)
+                if (bGZipped)
                     pbData = MemUtil.Decompress(pbData);
 
                 string strData = StrUtil.Utf8.GetString(pbData, 0, pbData.Length);
-				if(string.IsNullOrEmpty(strData)) { Debug.Assert(false); return; }
-
-				if(!char.IsWhiteSpace(strData[strData.Length - 1]))
-					strData += "\n";
+                if (string.IsNullOrEmpty(strData)) { Debug.Assert(false); return; }
 
                 StringBuilder sb = new StringBuilder();
-				for(int i = 0; i < strData.Length; ++i)
+                for (int i = 0; i <= strData.Length; ++i)
                 {
-					char ch = strData[i];
+                    char ch = ((i == strData.Length) ? ' ' : strData[i]);
 
-					if(char.IsWhiteSpace(ch))
+                    if (char.IsWhiteSpace(ch))
                     {
                         int cc = sb.Length;
-						if(cc > 0)
+                        if (cc > 0)
                         {
-							string strWord = sb.ToString();
-							Debug.Assert(strWord.Length == cc);
+                            char[] vWord = new char[cc];
+                            sb.CopyTo(0, vWord, 0, cc);
 
-							Dictionary<string, bool> d;
-							if(!m_dicts.TryGetValue(cc, out d))
+                            Dictionary<char[], bool> d;
+                            if (!g_dicts.TryGetValue(cc, out d))
                             {
-								d = new Dictionary<string, bool>();
-								m_dicts[cc] = d;
+                                d = new Dictionary<char[], bool>(MemUtil.ArrayHelperExOfChar);
+                                g_dicts[cc] = d;
                             }
 
-							d[strWord] = true;
+                            d[vWord] = true;
                             sb.Remove(0, cc);
                         }
                     }
                     else sb.Append(char.ToLower(ch));
                 }
             }
-			catch(Exception) { Debug.Assert(false); }
+            catch (Exception) { Debug.Assert(false); }
         }
     }
 }

src/KeePassLib2Android/Cryptography/QualityEstimation.cs

@@ -1,6 +1,6 @@
 /*
   KeePass Password Safe - The Open-Source Password Manager
-  Copyright (C) 2003-2017 Dominik Reichl <dominik.reichl@t-online.de>
+  Copyright (C) 2003-2025 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
@@ -19,8 +19,8 @@
 
 using System;
 using System.Collections.Generic;
-using System.Text;
 using System.Diagnostics;
+using System.Text;
 
 using KeePassLib.Cryptography.PasswordGenerator;
 using KeePassLib.Utility;
@@ -35,19 +35,19 @@ namespace KeePassLib.Cryptography
     {
         private static class PatternID
         {
-			public const char LowerAlpha = 'L';
-			public const char UpperAlpha = 'U';
-			public const char Digit = 'D';
-			public const char Special = 'S';
-			public const char High = 'H';
-			public const char Other = 'X';
+            internal const char LowerAlpha = 'L';
+            internal const char UpperAlpha = 'U';
+            internal const char Digit = 'D';
+            internal const char Special = 'S';
+            internal const char Latin1S = 'H';
+            internal const char Other = 'X';
 
-			public const char Dictionary = 'W';
-			public const char Repetition = 'R';
-			public const char Number = 'N';
-			public const char DiffSeq = 'C';
+            internal const char Dictionary = 'W';
+            internal const char Repetition = 'R';
+            internal const char Number = 'N';
+            internal const char DiffSeq = 'C';
 
-			public const string All = "LUDSHXWRNC";
+            internal const string All = "LUDSHXWRNC";
         }
 
         // private static class CharDistrib
@@ -84,8 +84,8 @@ namespace KeePassLib.Cryptography
 
             public QeCharType(char chTypeID, string strAlphabet, bool bIsConsecutive)
             {
-				if(strAlphabet == null) throw new ArgumentNullException();
-				if(strAlphabet.Length == 0) throw new ArgumentException();
+                if (strAlphabet == null) throw new ArgumentNullException();
+                if (strAlphabet.Length == 0) throw new ArgumentException();
 
                 m_chTypeID = chTypeID;
                 m_strAlph = strAlphabet;
@@ -101,7 +101,7 @@ namespace KeePassLib.Cryptography
 
             public QeCharType(char chTypeID, int nChars) // Catch-none set
             {
-				if(nChars <= 0) throw new ArgumentOutOfRangeException();
+                if (nChars <= 0) throw new ArgumentOutOfRangeException();
 
                 m_chTypeID = chTypeID;
                 m_strAlph = string.Empty;
@@ -114,7 +114,7 @@ namespace KeePassLib.Cryptography
 
             public bool Contains(char ch)
             {
-				if(m_chLast != char.MinValue)
+                if (m_chLast != char.MinValue)
                     return ((ch >= m_chFirst) && (ch <= m_chLast));
 
                 Debug.Assert(m_strAlph.Length > 0); // Don't call for catch-none set
@@ -125,7 +125,7 @@ namespace KeePassLib.Cryptography
         private sealed class EntropyEncoder
         {
             private readonly string m_strAlph;
-			private Dictionary<char, ulong> m_dHisto = new Dictionary<char, ulong>();
+            private readonly Dictionary<char, ulong> m_dHisto = new Dictionary<char, ulong>();
             private readonly ulong m_uBaseWeight;
             private readonly ulong m_uCharWeight;
             private readonly ulong m_uOccExclThreshold;
@@ -133,8 +133,8 @@ namespace KeePassLib.Cryptography
             public EntropyEncoder(string strAlphabet, ulong uBaseWeight,
                 ulong uCharWeight, ulong uOccExclThreshold)
             {
-				if(strAlphabet == null) throw new ArgumentNullException();
-				if(strAlphabet.Length == 0) throw new ArgumentException();
+                if (strAlphabet == null) throw new ArgumentNullException();
+                if (strAlphabet.Length == 0) throw new ArgumentException();
 
                 m_strAlph = strAlphabet;
                 m_uBaseWeight = uBaseWeight;
@@ -143,7 +143,7 @@ namespace KeePassLib.Cryptography
 
 #if DEBUG
                 Dictionary<char, bool> d = new Dictionary<char, bool>();
-				foreach(char ch in m_strAlph) { d[ch] = true; }
+                foreach (char ch in m_strAlph) { d[ch] = true; }
                 Debug.Assert(d.Count == m_strAlph.Length); // No duplicates
 #endif
             }
@@ -166,18 +166,18 @@ namespace KeePassLib.Cryptography
             public double GetOutputSize()
             {
                 ulong uTotalWeight = m_uBaseWeight * (ulong)m_strAlph.Length;
-				foreach(ulong u in m_dHisto.Values)
+                foreach (ulong u in m_dHisto.Values)
                 {
                     Debug.Assert(u >= 1);
-					if(u > m_uOccExclThreshold)
+                    if (u > m_uOccExclThreshold)
                         uTotalWeight += (u - m_uOccExclThreshold) * m_uCharWeight;
                 }
 
                 double dSize = 0.0, dTotalWeight = (double)uTotalWeight;
-				foreach(ulong u in m_dHisto.Values)
+                foreach (ulong u in m_dHisto.Values)
                 {
                     ulong uWeight = m_uBaseWeight;
-					if(u > m_uOccExclThreshold)
+                    if (u > m_uOccExclThreshold)
                         uWeight += (u - m_uOccExclThreshold) * m_uCharWeight;
 
                     dSize -= (double)u * Log2((double)uWeight / dTotalWeight);
@@ -189,7 +189,7 @@ namespace KeePassLib.Cryptography
 
         private sealed class MultiEntropyEncoder
         {
-			private Dictionary<char, EntropyEncoder> m_dEncs =
+            private readonly Dictionary<char, EntropyEncoder> m_dEncs =
                 new Dictionary<char, EntropyEncoder>();
 
             public MultiEntropyEncoder()
@@ -198,7 +198,7 @@ namespace KeePassLib.Cryptography
 
             public void AddEncoder(char chTypeID, EntropyEncoder ec)
             {
-				if(ec == null) { Debug.Assert(false); return; }
+                if (ec == null) { Debug.Assert(false); return; }
 
                 Debug.Assert(!m_dEncs.ContainsKey(chTypeID));
                 m_dEncs[chTypeID] = ec;
@@ -206,13 +206,13 @@ namespace KeePassLib.Cryptography
 
             public void Reset()
             {
-				foreach(EntropyEncoder ec in m_dEncs.Values) { ec.Reset(); }
+                foreach (EntropyEncoder ec in m_dEncs.Values) { ec.Reset(); }
             }
 
             public bool Write(char chTypeID, char chData)
             {
                 EntropyEncoder ec;
-				if(!m_dEncs.TryGetValue(chTypeID, out ec))
+                if (!m_dEncs.TryGetValue(chTypeID, out ec))
                     return false;
 
                 ec.Write(chData);
@@ -223,7 +223,7 @@ namespace KeePassLib.Cryptography
             {
                 double d = 0.0;
 
-				foreach(EntropyEncoder ec in m_dEncs.Values)
+                foreach (EntropyEncoder ec in m_dEncs.Values)
                 {
                     d += ec.GetOutputSize();
                 }
@@ -281,36 +281,31 @@ namespace KeePassLib.Cryptography
             }
         }
 
-		private static object m_objSyncInit = new object();
+        private static readonly object m_objSyncInit = new object();
         private static List<QeCharType> m_lCharTypes = null;
 
         private static void EnsureInitialized()
         {
-			lock(m_objSyncInit)
+            lock (m_objSyncInit)
             {
-				if(m_lCharTypes == null)
+                if (m_lCharTypes == null)
                 {
                     string strSpecial = PwCharSet.PrintableAsciiSpecial;
-					if(strSpecial.IndexOf(' ') >= 0) { Debug.Assert(false); }
-					else strSpecial = strSpecial + " ";
+                    if (strSpecial.IndexOf(' ') >= 0) { Debug.Assert(false); }
+                    else strSpecial += " ";
 
                     int nSp = strSpecial.Length;
-					int nHi = PwCharSet.HighAnsiChars.Length;
+                    int nL1S = PwCharSet.Latin1S.Length;
 
-					m_lCharTypes = new List<QeCharType>();
-
-					m_lCharTypes.Add(new QeCharType(PatternID.LowerAlpha,
-						PwCharSet.LowerCase, true));
-					m_lCharTypes.Add(new QeCharType(PatternID.UpperAlpha,
-						PwCharSet.UpperCase, true));
-					m_lCharTypes.Add(new QeCharType(PatternID.Digit,
-						PwCharSet.Digits, true));
-					m_lCharTypes.Add(new QeCharType(PatternID.Special,
-						strSpecial, false));
-					m_lCharTypes.Add(new QeCharType(PatternID.High,
-						PwCharSet.HighAnsiChars, false));
-					m_lCharTypes.Add(new QeCharType(PatternID.Other,
-						0x10000 - (2 * 26) - 10 - nSp - nHi));
+                    m_lCharTypes = new List<QeCharType>()
+                    {
+                        new QeCharType(PatternID.LowerAlpha, PwCharSet.LowerCase, true),
+                        new QeCharType(PatternID.UpperAlpha, PwCharSet.UpperCase, true),
+                        new QeCharType(PatternID.Digit, PwCharSet.Digits, true),
+                        new QeCharType(PatternID.Special, strSpecial, false),
+                        new QeCharType(PatternID.Latin1S, PwCharSet.Latin1S, false),
+                        new QeCharType(PatternID.Other, 0x10000 - (2 * 26) - 10 - nSp - nL1S)
+                    };
                 }
             }
         }
@@ -318,37 +313,37 @@ namespace KeePassLib.Cryptography
         /// <summary>
         /// Estimate the quality of a password.
         /// </summary>
-		/// <param name="vPasswordChars">Password to check.</param>
+        /// <param name="vPassword">Password to check.</param>
         /// <returns>Estimated bit-strength of the password.</returns>
-		public static uint EstimatePasswordBits(char[] vPasswordChars)
+        public static uint EstimatePasswordBits(char[] vPassword)
         {
-			if(vPasswordChars == null) { Debug.Assert(false); return 0; }
-			if(vPasswordChars.Length == 0) return 0;
+            if (vPassword == null) { Debug.Assert(false); return 0; }
+            if (vPassword.Length == 0) return 0;
 
             EnsureInitialized();
 
-			int n = vPasswordChars.Length;
+            int n = vPassword.Length;
             List<QePatternInstance>[] vPatterns = new List<QePatternInstance>[n];
-			for(int i = 0; i < n; ++i)
+            for (int i = 0; i < n; ++i)
             {
                 vPatterns[i] = new List<QePatternInstance>();
 
                 QePatternInstance piChar = new QePatternInstance(i, 1,
-					GetCharType(vPasswordChars[i]));
+                    GetCharType(vPassword[i]));
                 vPatterns[i].Add(piChar);
             }
 
-			FindRepetitions(vPasswordChars, vPatterns);
-			FindNumbers(vPasswordChars, vPatterns);
-			FindDiffSeqs(vPasswordChars, vPatterns);
-			FindPopularPasswords(vPasswordChars, vPatterns);
+            FindRepetitions(vPassword, vPatterns);
+            FindNumbers(vPassword, vPatterns);
+            FindDiffSeqs(vPassword, vPatterns);
+            FindPopularPasswords(vPassword, vPatterns);
 
             // Encoders must not be static, because the entropy estimation
             // may run concurrently in multiple threads and the encoders are
             // not read-only
             EntropyEncoder ecPattern = new EntropyEncoder(PatternID.All, 0, 1, 0);
             MultiEntropyEncoder mcData = new MultiEntropyEncoder();
-			for(int i = 0; i < (m_lCharTypes.Count - 1); ++i)
+            for (int i = 0; i < (m_lCharTypes.Count - 1); ++i)
             {
                 // Let m be the alphabet size. In order to ensure that two same
                 // characters cost at least as much as a single character, for
@@ -371,25 +366,25 @@ namespace KeePassLib.Cryptography
 
             Stack<QePathState> sRec = new Stack<QePathState>();
             sRec.Push(new QePathState(0, new List<QePatternInstance>()));
-			while(sRec.Count > 0)
+            while (sRec.Count > 0)
             {
                 int tDiff = Environment.TickCount - tStart;
-				if(tDiff > 500) break;
+                if (tDiff > 500) break;
 
                 QePathState s = sRec.Pop();
 
-				if(s.Position >= n)
+                if (s.Position >= n)
                 {
                     Debug.Assert(s.Position == n);
 
-					double dblCost = ComputePathCost(s.Path, vPasswordChars,
+                    double dblCost = ComputePathCost(s.Path, vPassword,
                         ecPattern, mcData);
-					if(dblCost < dblMinCost) dblMinCost = dblCost;
+                    if (dblCost < dblMinCost) dblMinCost = dblCost;
                 }
                 else
                 {
                     List<QePatternInstance> lSubs = vPatterns[s.Position];
-					for(int i = lSubs.Count - 1; i >= 0; --i)
+                    for (int i = lSubs.Count - 1; i >= 0; --i)
                     {
                         QePatternInstance pi = lSubs[i];
                         Debug.Assert(pi.Position == s.Position);
@@ -418,13 +413,14 @@ namespace KeePassLib.Cryptography
         /// <returns>Estimated bit-strength of the password.</returns>
         public static uint EstimatePasswordBits(byte[] pbUnprotectedUtf8)
         {
-			if(pbUnprotectedUtf8 == null) { Debug.Assert(false); return 0; }
+            if (pbUnprotectedUtf8 == null) { Debug.Assert(false); return 0; }
 
-			char[] vChars = StrUtil.Utf8.GetChars(pbUnprotectedUtf8);
-			uint uResult = EstimatePasswordBits(vChars);
-			MemUtil.ZeroArray<char>(vChars);
+            char[] v = StrUtil.Utf8.GetChars(pbUnprotectedUtf8);
+            uint r;
+            try { r = EstimatePasswordBits(v); }
+            finally { MemUtil.ZeroArray<char>(v); }
 
-			return uResult;
+            return r;
         }
 
         private static QeCharType GetCharType(char ch)
@@ -432,9 +428,9 @@ namespace KeePassLib.Cryptography
             int nTypes = m_lCharTypes.Count;
             Debug.Assert((nTypes > 0) && (m_lCharTypes[nTypes - 1].CharCount > 256));
 
-			for(int i = 0; i < (nTypes - 1); ++i)
+            for (int i = 0; i < (nTypes - 1); ++i)
             {
-				if(m_lCharTypes[i].Contains(ch))
+                if (m_lCharTypes[i].Contains(ch))
                     return m_lCharTypes[i];
             }
 
@@ -445,19 +441,19 @@ namespace KeePassLib.Cryptography
             char[] vPassword, EntropyEncoder ecPattern, MultiEntropyEncoder mcData)
         {
             ecPattern.Reset();
-			for(int i = 0; i < l.Count; ++i)
+            for (int i = 0; i < l.Count; ++i)
                 ecPattern.Write(l[i].PatternID);
             double dblPatternCost = ecPattern.GetOutputSize();
 
             mcData.Reset();
             double dblDataCost = 0.0;
-			foreach(QePatternInstance pi in l)
+            foreach (QePatternInstance pi in l)
             {
                 QeCharType tChar = pi.SingleCharType;
-				if(tChar != null)
+                if (tChar != null)
                 {
                     char ch = vPassword[pi.Position];
-					if(!mcData.Write(tChar.TypeID, ch))
+                    if (!mcData.Write(tChar.TypeID, ch))
                         dblDataCost += pi.Cost;
                 }
                 else dblDataCost += pi.Cost;
@@ -474,7 +470,7 @@ namespace KeePassLib.Cryptography
 
             char[] vLower = new char[n];
             char[] vLeet = new char[n];
-			for(int i = 0; i < n; ++i)
+            for (int i = 0; i < n; ++i)
             {
                 char ch = vPassword[i];
 
@@ -482,27 +478,27 @@ namespace KeePassLib.Cryptography
                 vLeet[i] = char.ToLower(DecodeLeetChar(ch));
             }
 
-			char chErased = default(char);
+            char chErased = default(char); // The value that Array.Clear uses
             Debug.Assert(chErased == char.MinValue);
 
             int nMaxLen = Math.Min(n, PopularPasswords.MaxLength);
-			for(int nSubLen = nMaxLen; nSubLen >= 3; --nSubLen)
+            for (int nSubLen = nMaxLen; nSubLen >= 3; --nSubLen)
             {
-				if(!PopularPasswords.ContainsLength(nSubLen)) continue;
+                if (!PopularPasswords.ContainsLength(nSubLen)) continue;
 
                 char[] vSub = new char[nSubLen];
 
-				for(int i = 0; i <= (n - nSubLen); ++i)
+                for (int i = 0; i <= (n - nSubLen); ++i)
                 {
-					if(Array.IndexOf<char>(vLower, chErased, i, nSubLen) >= 0)
+                    if (Array.IndexOf<char>(vLower, chErased, i, nSubLen) >= 0)
                         continue;
 
                     Array.Copy(vLower, i, vSub, 0, nSubLen);
-					if(!EvalAddPopularPasswordPattern(vPatterns, vPassword,
+                    if (!EvalAddPopularPasswordPattern(vPatterns, vPassword,
                         i, vSub, 0.0))
                     {
                         Array.Copy(vLeet, i, vSub, 0, nSubLen);
-						if(EvalAddPopularPasswordPattern(vPatterns, vPassword,
+                        if (EvalAddPopularPasswordPattern(vPatterns, vPassword,
                             i, vSub, 1.5))
                         {
                             Array.Clear(vLower, i, nSubLen); // Not vLeet
@@ -515,14 +511,19 @@ namespace KeePassLib.Cryptography
                         Debug.Assert(vLower[i] == chErased);
                     }
                 }
+
+                MemUtil.ZeroArray<char>(vSub);
             }
+
+            MemUtil.ZeroArray<char>(vLower);
+            MemUtil.ZeroArray<char>(vLeet);
         }
 
         private static bool EvalAddPopularPasswordPattern(List<QePatternInstance>[] vPatterns,
             char[] vPassword, int i, char[] vSub, double dblCostPerMod)
         {
             ulong uDictSize;
-			if(!PopularPasswords.IsPopularPassword(vSub, out uDictSize))
+            if (!PopularPasswords.IsPopularPassword(vSub, out uDictSize))
                 return false;
 
             int n = vSub.Length;
@@ -532,9 +533,9 @@ namespace KeePassLib.Cryptography
 
             // dblCost += log2(n binom d)
             int k = Math.Min(d, n - d);
-			for(int j = n; j > (n - k); --j)
+            for (int j = n; j > (n - k); --j)
                 dblCost += Log2(j);
-			for(int j = k; j >= 2; --j)
+            for (int j = k; j >= 2; --j)
                 dblCost -= Log2(j);
 
             dblCost += dblCostPerMod * (double)d;
@@ -546,19 +547,19 @@ namespace KeePassLib.Cryptography
 
         private static char DecodeLeetChar(char chLeet)
         {
-			if((chLeet >= '\u00C0') && (chLeet <= '\u00C6')) return 'a';
-			if((chLeet >= '\u00C8') && (chLeet <= '\u00CB')) return 'e';
-			if((chLeet >= '\u00CC') && (chLeet <= '\u00CF')) return 'i';
-			if((chLeet >= '\u00D2') && (chLeet <= '\u00D6')) return 'o';
-			if((chLeet >= '\u00D9') && (chLeet <= '\u00DC')) return 'u';
-			if((chLeet >= '\u00E0') && (chLeet <= '\u00E6')) return 'a';
-			if((chLeet >= '\u00E8') && (chLeet <= '\u00EB')) return 'e';
-			if((chLeet >= '\u00EC') && (chLeet <= '\u00EF')) return 'i';
-			if((chLeet >= '\u00F2') && (chLeet <= '\u00F6')) return 'o';
-			if((chLeet >= '\u00F9') && (chLeet <= '\u00FC')) return 'u';
+            if ((chLeet >= '\u00C0') && (chLeet <= '\u00C6')) return 'a';
+            if ((chLeet >= '\u00C8') && (chLeet <= '\u00CB')) return 'e';
+            if ((chLeet >= '\u00CC') && (chLeet <= '\u00CF')) return 'i';
+            if ((chLeet >= '\u00D2') && (chLeet <= '\u00D6')) return 'o';
+            if ((chLeet >= '\u00D9') && (chLeet <= '\u00DC')) return 'u';
+            if ((chLeet >= '\u00E0') && (chLeet <= '\u00E6')) return 'a';
+            if ((chLeet >= '\u00E8') && (chLeet <= '\u00EB')) return 'e';
+            if ((chLeet >= '\u00EC') && (chLeet <= '\u00EF')) return 'i';
+            if ((chLeet >= '\u00F2') && (chLeet <= '\u00F6')) return 'o';
+            if ((chLeet >= '\u00F9') && (chLeet <= '\u00FC')) return 'u';
 
             char ch;
-			switch(chLeet)
+            switch (chLeet)
             {
                 case '4':
                 case '@':
@@ -621,9 +622,9 @@ namespace KeePassLib.Cryptography
             char[] v2, int iOffset2, int nLength)
         {
             int nDist = 0;
-			for(int i = 0; i < nLength; ++i)
+            for (int i = 0; i < nLength; ++i)
             {
-				if(v1[iOffset1 + i] != v2[iOffset2 + i]) ++nDist;
+                if (v1[iOffset1 + i] != v2[iOffset2 + i]) ++nDist;
             }
 
             return nDist;
@@ -637,15 +638,15 @@ namespace KeePassLib.Cryptography
             Array.Copy(vPassword, v, n);
 
             char chErased = char.MaxValue;
-			for(int m = (n / 2); m >= 3; --m)
+            for (int m = (n / 2); m >= 3; --m)
             {
-				for(int x1 = 0; x1 <= (n - (2 * m)); ++x1)
+                for (int x1 = 0; x1 <= (n - (2 * m)); ++x1)
                 {
                     bool bFoundRep = false;
 
-					for(int x2 = (x1 + m); x2 <= (n - m); ++x2)
+                    for (int x2 = (x1 + m); x2 <= (n - m); ++x2)
                     {
-						if(PartsEqual(v, x1, x2, m))
+                        if (PartsEqual(v, x1, x2, m))
                         {
                             double dblCost = Log2(x1 + 1) + Log2(m);
                             vPatterns[x2].Add(new QePatternInstance(x2, m,
@@ -656,16 +657,18 @@ namespace KeePassLib.Cryptography
                         }
                     }
 
-					if(bFoundRep) ErasePart(v, x1, m, ref chErased);
+                    if (bFoundRep) ErasePart(v, x1, m, ref chErased);
                 }
             }
+
+            MemUtil.ZeroArray<char>(v);
         }
 
         private static bool PartsEqual(char[] v, int x1, int x2, int nLength)
         {
-			for(int i = 0; i < nLength; ++i)
+            for (int i = 0; i < nLength; ++i)
             {
-				if(v[x1 + i] != v[x2 + i]) return false;
+                if (v[x1 + i] != v[x2 + i]) return false;
             }
 
             return true;
@@ -673,7 +676,7 @@ namespace KeePassLib.Cryptography
 
         private static void ErasePart(char[] v, int i, int n, ref char chErased)
         {
-			for(int j = 0; j < n; ++j)
+            for (int j = 0; j < n; ++j)
             {
                 v[i + j] = chErased;
                 --chErased;
@@ -685,33 +688,35 @@ namespace KeePassLib.Cryptography
         {
             int n = vPassword.Length;
             StringBuilder sb = new StringBuilder();
-			for(int i = 0; i < n; ++i)
+
+            for (int i = 0; i < n; ++i)
             {
                 char ch = vPassword[i];
-				if((ch >= '0') && (ch <= '9')) sb.Append(ch);
+                if ((ch >= '0') && (ch <= '9')) sb.Append(ch);
                 else
                 {
-					AddNumberPattern(vPatterns, sb.ToString(), i - sb.Length);
+                    AddNumberPattern(vPatterns, sb, i - sb.Length);
                     sb.Remove(0, sb.Length);
                 }
             }
-			AddNumberPattern(vPatterns, sb.ToString(), n - sb.Length);
+            AddNumberPattern(vPatterns, sb, n - sb.Length);
         }
 
         private static void AddNumberPattern(List<QePatternInstance>[] vPatterns,
-			string strNumber, int i)
+            StringBuilder sb, int i)
         {
-			if(strNumber.Length <= 2) return;
+            if (sb.Length <= 2) return;
+            string strNumber = sb.ToString();
 
             int nZeros = 0;
-			for(int j = 0; j < strNumber.Length; ++j)
+            for (int j = 0; j < strNumber.Length; ++j)
             {
-				if(strNumber[j] != '0') break;
+                if (strNumber[j] != '0') break;
                 ++nZeros;
             }
 
             double dblCost = Log2(nZeros + 1);
-			if(nZeros < strNumber.Length)
+            if (nZeros < strNumber.Length)
             {
                 string strNonZero = strNumber.Substring(nZeros);
 
@@ -720,7 +725,7 @@ namespace KeePassLib.Cryptography
 				catch(Exception) { Debug.Assert(false); return; }
 #else
                 double d;
-				if(double.TryParse(strNonZero, out d))
+                if (double.TryParse(strNonZero, out d))
                     dblCost += Log2(d);
                 else { Debug.Assert(false); return; }
 #endif
@@ -733,17 +738,18 @@ namespace KeePassLib.Cryptography
         private static void FindDiffSeqs(char[] vPassword,
             List<QePatternInstance>[] vPatterns)
         {
-			int d = int.MinValue, p = 0;
-			string str = new string(vPassword) + new string(char.MaxValue, 1);
+            int n = vPassword.Length;
+            int d = int.MaxValue, p = 0;
 
-			for(int i = 1; i < str.Length; ++i)
+            for (int i = 1; i <= n; ++i)
             {
-				int dCur = (int)str[i] - (int)str[i - 1];
-				if(dCur != d)
+                int dCur = ((i == n) ? int.MinValue :
+                    ((int)vPassword[i] - (int)vPassword[i - 1]));
+                if (dCur != d)
                 {
-					if((i - p) >= 3) // At least 3 chars involved
+                    if ((i - p) >= 3) // At least 3 chars involved
                     {
-						QeCharType ct = GetCharType(str[p]);
+                        QeCharType ct = GetCharType(vPassword[p]);
                         double dblCost = ct.CharSize + Log2(i - p - 1);
 
                         vPatterns[p].Add(new QePatternInstance(p,

src/KeePassLib2Android/Delegates/Handlers.cs

@@ -46,4 +46,12 @@ namespace KeePassLib.Delegates
 	public delegate void VoidDelegate();
 
 	public delegate string StrPwEntryDelegate(string str, PwEntry pe);
+
+    public delegate TResult GFunc<TResult>();
+    public delegate TResult GFunc<T, TResult>(T o);
+    public delegate TResult GFunc<T1, T2, TResult>(T1 o1, T2 o2);
+    public delegate TResult GFunc<T1, T2, T3, TResult>(T1 o1, T2 o2, T3 o3);
+    public delegate TResult GFunc<T1, T2, T3, T4, TResult>(T1 o1, T2 o2, T3 o3, T4 o4);
+    public delegate TResult GFunc<T1, T2, T3, T4, T5, TResult>(T1 o1, T2 o2, T3 o3, T4 o4, T5 o5);
+    public delegate TResult GFunc<T1, T2, T3, T4, T5, T6, TResult>(T1 o1, T2 o2, T3 o3, T4 o4, T5 o5, T6 o6);
 }

src/keepass2android-app/EntryActivity.cs

@@ -1546,10 +1546,10 @@ namespace keepass2android
             string url = _stringViews[urlFieldKey].Text;
 			if (url == null) return false;
 
-			// Default http:// if no protocol specified
+			// Default https:// if no protocol specified
 			if ((!url.Contains(":") || (url.StartsWith("www."))))
 			{
-				url = "http://" + url;
+				url = "https://" + url;
 			}
 
 			try

src/keepass2android-app/GeneratePasswordActivity.cs

@@ -23,6 +23,7 @@ using Android.App;
 using Android.App.Admin;
 using Android.Content;
 using Android.Content.PM;
+using Android.Content.Res;
 using Android.Graphics;
 using Android.OS;
 using Android.Preferences;
@@ -66,8 +67,13 @@ namespace keepass2android
             Resource.Id.cb_exclude_lookalike
         };
 
+        
+
 		PasswordFont _passwordFont = new PasswordFont();
 
+        private static object _popularPasswordsLock = new object();
+        private static bool _popularPasswordsInitialized = false;
+
 
         private ActivityDesign _design;
 	    public GeneratePasswordActivity()
@@ -302,6 +308,10 @@ namespace keepass2android
 
 
             EditText txtPasswordToSet = (EditText) FindViewById(Resource.Id.password_edit);
+            txtPasswordToSet.TextChanged += (sender, args) =>
+            {
+                Task.Run(() => UpdatePasswordStrengthEstimate(txtPasswordToSet.Text));
+            };
 
             _passwordFont.ApplyTo(txtPasswordToSet);
 
@@ -467,17 +477,48 @@ namespace keepass2android
                 return;
 
             String password = "";
-            uint passwordBits = 0;
+            
             
             Task.Run(() =>
             {
                 password = GeneratePassword();
-                passwordBits = QualityEstimation.EstimatePasswordBits(password.ToCharArray());
                 RunOnUiThread(() =>
                 {
                     EditText txtPassword = (EditText)FindViewById(Resource.Id.password_edit);
                     txtPassword.Text = password;
+                    UpdateProfileSpinnerSelection();
+                });
+            });
             
+        }
+
+        private void UpdatePasswordStrengthEstimate(string password)
+        {
+            lock (_popularPasswordsLock)
+            {
+                if (!_popularPasswordsInitialized)
+                {
+
+                    using (StreamReader sr = new StreamReader(Assets.Open("MostPopularPasswords.txt")))
+                    {
+                        var bytes = default(byte[]);
+                        using (var memstream = new MemoryStream())
+                        {
+                            sr.BaseStream.CopyTo(memstream);
+                            bytes = memstream.ToArray();
+                        }
+                        PopularPasswords.Add(bytes, false);
+                    }
+                }
+                    
+            }
+            uint passwordBits = QualityEstimation.EstimatePasswordBits(password.ToCharArray());
+
+
+
+
+            RunOnUiThread(() =>
+            {
                 var progressBar = FindViewById<ProgressBar>(Resource.Id.pb_password_strength);
 
                 progressBar.Progress = (int)passwordBits;
@@ -503,13 +544,7 @@ namespace keepass2android
                     PorterDuff.Mode.SrcIn));
 
                 FindViewById<TextView>(Resource.Id.tv_password_strength).Text = " " + passwordBits + " bits";
-
-
-
-                    UpdateProfileSpinnerSelection();
             });
-            });
-            
         }
 
         private void UpdateProfileSpinnerSelection()

src/keepass2android-app/PasswordActivity.cs

@@ -1423,6 +1423,8 @@ namespace keepass2android
 			if (cbQuickUnlock == null)
 				throw new NullPointerException("cpQuickUnlock");
 			App.Kp2a.SetQuickUnlockEnabled(cbQuickUnlock.Checked);
+            App.Kp2a.ScreenLockWasEnabledWhenOpeningDatabase =
+                (((KeyguardManager)GetSystemService(Context.KeyguardService)!)!).IsDeviceSecure;
 
             if ((_loadDbFileTask != null) &&  (App.Kp2a.OfflineMode != _loadDbTaskOffline))
 			{

src/keepass2android-app/QuickUnlock.cs

@@ -25,6 +25,7 @@ using Android.Widget;
 using Android.Content.PM;
 using KeePassLib.Keys;
 using Android.Preferences;
+using Android.Provider;
 using Android.Runtime;
 
 using Android.Views.InputMethods;
@@ -162,6 +163,29 @@ namespace keepass2android
             if (bundle != null)
                 numFailedAttempts = bundle.GetInt(NumFailedAttemptsKey, 0);
 
+            FindViewById(Resource.Id.QuickUnlock_buttonEnableLock).Click += (object sender, EventArgs e) =>
+            {
+				Intent intent = new Intent(Settings.ActionSecuritySettings);
+                StartActivity(intent);
+
+            };
+
+            FindViewById(Resource.Id.QuickUnlock_buttonCloseDb).Click += (object sender, EventArgs e) =>
+            {
+                App.Kp2a.Lock(false);
+            };
+
+            if (App.Kp2a.ScreenLockWasEnabledWhenOpeningDatabase == false)
+            {
+				FindViewById(Resource.Id.QuickUnlockForm).Visibility = ViewStates.Gone;
+                FindViewById(Resource.Id.QuickUnlockBlocked).Visibility = ViewStates.Visible;
+            }
+            else
+            {
+                FindViewById(Resource.Id.QuickUnlockForm).Visibility = ViewStates.Visible;
+                FindViewById(Resource.Id.QuickUnlockBlocked).Visibility = ViewStates.Gone;
+            }
+
 
 
         }

src/keepass2android-app/Resources/layout/QuickUnlock.xml

@@ -79,6 +79,12 @@ android:paddingRight="16dp"
           android:paddingTop="16dp">
 
         
+        <LinearLayout
+          android:layout_width="wrap_content"
+          android:layout_height="wrap_content"
+          android:orientation="horizontal"
+          android:id="@+id/QuickUnlockForm">
+
           <TextView
             android:id="@+id/QuickUnlock_label"
             android:text="@string/QuickUnlock_label"
@@ -88,11 +94,6 @@ android:paddingRight="16dp"
             android:textSize="14sp"
           />
 
-        <LinearLayout
-          android:layout_width="wrap_content"
-          android:layout_height="wrap_content"
-          android:orientation="horizontal">
-
           <EditText
             android:inputType="textPassword"
             android:layout_width="wrap_content"
@@ -121,6 +122,60 @@ android:paddingRight="16dp"
 
         </LinearLayout>
 
+        <LinearLayout
+          android:layout_width="match_parent"
+          android:layout_height="wrap_content"
+          android:orientation="vertical"
+          android:background="@color/md_theme_secondaryContainer"
+          android:id="@+id/QuickUnlockBlocked"
+          android:padding="16dp"
+          android:layout_gravity="center">
+
+          <TextView
+            android:id="@+id/quick_unlock_blocked_title"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="@string/password_based_quick_unlock_not_available"
+            android:textSize="16sp"
+            android:textStyle="bold"
+            android:gravity="center"
+            android:paddingBottom="8dp"/>
+
+          <TextView
+            android:id="@+id/alert_message"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="@string/password_based_quick_unlock_not_available_text"
+            android:textSize="16sp"
+                            android:paddingBottom="8dp"/>
+          <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="vertical">
+            <Button  
+              android:id="@+id/QuickUnlock_buttonEnableLock"
+              android:layout_width="wrap_content"
+              android:layout_height="wrap_content"
+              android:layout_gravity="center"
+              android:backgroundTint="@color/md_theme_secondary"
+              android:textColor="@android:color/white"
+              android:text="@string/enable_screen_lock"
+              android:fontFamily="sans-serif-medium"   />
+
+              <Button  
+              android:id="@+id/QuickUnlock_buttonCloseDb"
+              android:layout_width="wrap_content"
+              android:layout_height="wrap_content"
+              android:layout_gravity="center"
+              android:backgroundTint="@color/md_theme_secondary"
+              android:textColor="@android:color/white"
+              android:fontFamily="sans-serif-medium"  
+              android:text="@string/QuickUnlock_lockButton" />
+            
+            </LinearLayout>
+            
+
+          </LinearLayout>
       
         <View
         android:id="@+id/spacing"

src/keepass2android-app/Resources/values/strings.xml

@@ -93,6 +93,8 @@
   <string name="disable_fingerprint_unlock">Disable Biometric Unlock</string>
   <string name="enable_fingerprint_unlock">Enable full Biometric Unlock</string>
   <string name="enable_fingerprint_quickunlock">Enable Biometric Unlock for QuickUnlock</string>
+  <string name="password_based_quick_unlock_not_available">Password-based QuickUnlock not available</string>
+  <string name="password_based_quick_unlock_not_available_text">QuickUnlock using a part of your password is blocked because screen lock is not activated on your device. This behavior is to protect you in case somebody watched you entering your QuickUnlock key.</string>
   <string name="fingerprint_unlock_failed">Biometric Unlock failed. Decryption key was invalidated by Android OS. This usually happens if a biometric authentication or security settings were changed. </string>
   <string name="fingerprint_disabled_wrong_masterkey">Unlocking the database failed: Invalid composite key. Biometric Unlock was disabled because apparently the stored master password is no longer valid. </string>
   <string name="fingerprint_reenable">Please re-enable Biometric Unlock for the new master password.</string>
@@ -319,6 +321,7 @@
   <string name="QuickUnlock_label_secure">Enter QuickUnlock code:</string>
   <string name="QuickUnlock_button">QuickUnlock!</string>
   <string name="QuickUnlock_lockButton">Close database</string>
+  <string name="enable_screen_lock">Enable screen lock</string>
   <string name="QuickUnlockDefaultEnabled_title">Enable QuickUnlock by default</string>
   <string name="QuickUnlockDefaultEnabled_summary">Defines whether QuickUnlock is enabled by default or not.</string>
   <string name="ViewDatabaseSecure_title">Protect database display</string>

src/keepass2android-app/Resources/xml/network_security_config.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <network-security-config>
-  <base-config cleartextTrafficPermitted="true">
+  <base-config>
     <trust-anchors>
       <certificates src="system" />
       <certificates src="user" />

src/keepass2android-app/app/App.cs

@@ -351,6 +351,9 @@ namespace keepass2android
 			QuickUnlockEnabled = enabled;
 		}
 
+		public bool ScreenLockWasEnabledWhenOpeningDatabase { get; set; }
+
+
         public bool QuickUnlockEnabled { get; private set; }
 
 		public int QuickUnlockKeyLength { get; private set; }