C# PasswordGenerator.PwProfile类代码示例

		public static PwgError Generate(out ProtectedString psOut,
			PwProfile pwProfile, byte[] pbUserEntropy,
			CustomPwGeneratorPool pwAlgorithmPool)
		{
			Debug.Assert(pwProfile != null);
			if(pwProfile == null) throw new ArgumentNullException("pwProfile");

			PwgError e = PwgError.Unknown;
			CryptoRandomStream crs = null;
			byte[] pbKey = null;
			try
			{
				crs = CreateRandomStream(pbUserEntropy, out pbKey);

				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; }
			}
			finally
			{
				if(crs != null) crs.Dispose();
				if(pbKey != null) MemUtil.ZeroByteArray(pbKey);
			}

			return e;
		}

		public static PwgError Generate(ProtectedString psOutBuffer,
			PwProfile pwProfile, CryptoRandomStream crsRandomSource)
		{
			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)
				{
					Array.Clear(vGenerated, 0, vGenerated.Length);
					return PwgError.TooFewCharacters;
				}

				vGenerated[nIndex] = ch;
			}

			byte[] pbUTF8 = Encoding.UTF8.GetBytes(vGenerated);
			psOutBuffer.SetString(Encoding.UTF8.GetString(pbUTF8, 0, pbUTF8.Length));
			Array.Clear(pbUTF8, 0, pbUTF8.Length);
			Array.Clear(vGenerated, 0, vGenerated.Length);

			return PwgError.Success;
		}

        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)
                {
                    Array.Clear(vGenerated, 0, vGenerated.Length);
                    return PwgError.TooFewCharacters;
                }

                vGenerated[nIndex] = ch;
            }

            byte[] pbUtf8 = StrUtil.Utf8.GetBytes(vGenerated);
            psOut = new ProtectedString(true, pbUtf8);
            MemUtil.ZeroByteArray(pbUtf8);
            Array.Clear(vGenerated, 0, vGenerated.Length);

            return PwgError.Success;
        }

        public static int CompareProfilesByName(PwProfile a, PwProfile b)
        {
            if(a == b) return 0;
            if(a == null) { Debug.Assert(false); return -1; }
            if(b == null) { Debug.Assert(false); return 1; }

            return StrUtil.CompareNaturally(a.Name, b.Name);
        }

		public static byte[] CollectEntropyIfEnabled(PwProfile pp)
		{
			if(pp.CollectUserEntropy == false) return null;

			EntropyForm ef = new EntropyForm();
			if(ef.ShowDialog() == DialogResult.OK)
				return ef.GeneratedEntropy;

			return null;
		}

		/// <summary>
		/// Initialize this password generator form instance.
		/// </summary>
		/// <param name="pwInitial">Initial options (may be <c>null</c>).</param>
		public void InitEx(PwProfile pwInitial, bool bCanAccept, bool bForceInTaskbar)
		{
			m_optInitial = pwInitial;
			m_bCanAccept = bCanAccept;

			// m_bForceInTaskbar = bForceInTaskbar;
			// Set ShowInTaskbar immediately, not later, otherwise the form
			// can disappear:
			// https://sourceforge.net/p/keepass/discussion/329220/thread/c95b5644/
			if(bForceInTaskbar) this.ShowInTaskbar = true;
		}

        private static void AddStdPattern(string strName, string strPattern)
        {
            PwProfile p = new PwProfile();

            p.Name = strName;
            p.CollectUserEntropy = false;
            p.GeneratorType = PasswordGeneratorType.Pattern;
            p.Pattern = strPattern;

            Program.Config.PasswordGenerator.UserProfiles.Add(p);
        }

        public static byte[] CollectEntropyIfEnabled(PwProfile pp)
        {
            if(!pp.CollectUserEntropy) return null;

            EntropyForm ef = new EntropyForm();
            if(UIUtil.ShowDialogNotValue(ef, DialogResult.OK)) return null;

            byte[] pbGen = ef.GeneratedEntropy;
            UIUtil.DestroyForm(ef);
            return pbGen;
        }

		private static void AddStdPattern(string strName, string strPattern)
		{
			PwProfile p = new PwProfile();

			p.Name = strName + PwGeneratorUtil.BuiltInSuffix;
			p.CollectUserEntropy = false;
			p.GeneratorType = PasswordGeneratorType.Pattern;
			p.Pattern = strPattern;

			m_lBuiltIn.Add(p);
		}

 public override ProtectedString Generate(PwProfile prf, CryptoRandomStream crsRandomSource)
 {
     if (prf == null) { Debug.Assert(false); }
     else
     {
         Debug.Assert(prf.CustomAlgorithmUuid == Convert.ToBase64String(
             m_uuid.UuidBytes, Base64FormattingOptions.None));
     }
     Random keylen = new Random((int)crsRandomSource.GetRandomUInt64());
     int k = keylen.Next(3, 7);
     return new ProtectedString(false, cockPwdGenerator(k,keylen));
 }

        public override ProtectedString Generate(PwProfile prf, CryptoRandomStream crsRandomSource)
        {
            if (prf == null)
                Debug.Assert(false);
            else
                Debug.Assert(prf.CustomAlgorithmUuid == Convert.ToBase64String(m_uuid.UuidBytes, Base64FormattingOptions.None));

            if (string.IsNullOrEmpty(settings.WordListLocation))
            {
                System.Windows.Forms.MessageBox.Show("No word list location");
                GetSettingsFromUser();
                return null;
            }

            if (!System.IO.File.Exists(settings.WordListLocation))
            {
                System.Windows.Forms.MessageBox.Show(string.Format("Word List doesn't exist at location {0}", settings.WordListLocation));
                GetSettingsFromUser();
                return null;
            }

            try
            {
                if (words == null)
                    words = System.IO.File.ReadAllLines(settings.WordListLocation);

                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < settings.NumberOfWords; i++)
                {
                    ulong u = crsRandomSource.GetRandomUInt64();
                    u %= (ulong)(words.Length - 1);

                    if (i > 0) sb.Append(settings.Separator);

                    string word = words[u];
                    if (i == 0 && word.Length > 1)
                        word = word.Substring(0, 1).ToUpper() + word.Substring(1, word.Length - 1);

                    sb.Append(word);
                }
                sb.Append(settings.TrailingTrash);
                return new ProtectedString(false, sb.ToString());
            }

            catch (Exception ex)
            {
                System.Windows.Forms.MessageBox.Show(string.Format("Encountered this error while generating password: {0}", ex.Message));
            }
            return null;
        }

		internal static char GenerateCharacter(PwProfile pwProfile,
			PwCharSet pwCharSet, CryptoRandomStream crsRandomSource)
		{
			if(pwCharSet.Size == 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;
		}

public void ExpandPattern()
{
    // arrange
    var psOutBuffer = new ProtectedString();
    var pwProfile = new PwProfile();
    pwProfile.Pattern = "g{5}";
    var pbKey = new byte[] { 0x00 };
    var crsRandomSource = new CryptoRandomStream(CrsAlgorithm.Salsa20, pbKey);
    var error = PatternBasedGenerator.Generate(psOutBuffer, pwProfile, crsRandomSource);

    // act
    // nothing to do as ExpandPattern() would have been called by calling Generate()

    // assert
    Assert.AreEqual(PwgError.Success, error);
    var actual = psOutBuffer.ReadString();
    Assert.AreEqual("ggggg", actual);
}

        public override ProtectedString Generate(PwProfile prf, CryptoRandomStream crsRandomSource)
        {
            Random r = new Random((int)crsRandomSource.GetRandomUInt64());
            var opt = new DiceWareOptions(prf.CustomAlgorithmOptions);

            string result = "";
            int word = 0;

            for (int i = 0; i < 5 * opt.WordCount; i++)
            {
                word *= 10;
                word += (1 + r.Next(6));

                if ((i + 1) % 5 == 0 && i > 0)
                {
                    result += words[word];
                    result += " ";

                    word = 0;
                }
            }

            return new ProtectedString(true, result.Trim());
        }

		public static PwgError Generate(ProtectedString psOutBuffer,
			PwProfile pwProfile, byte[] pbUserEntropy,
			CustomPwGeneratorPool pwAlgorithmPool)
		{
			Debug.Assert(psOutBuffer != null);
			if(psOutBuffer == null) throw new ArgumentNullException("psOutBuffer");
			Debug.Assert(pwProfile != null);
			if(pwProfile == null) throw new ArgumentNullException("pwProfile");

			psOutBuffer.Clear();

			CryptoRandomStream crs = CreateCryptoStream(pbUserEntropy);
			PwgError e = PwgError.Unknown;

			if(pwProfile.GeneratorType == PasswordGeneratorType.CharSet)
				e = CharSetBasedGenerator.Generate(psOutBuffer, pwProfile, crs);
			else if(pwProfile.GeneratorType == PasswordGeneratorType.Pattern)
				e = PatternBasedGenerator.Generate(psOutBuffer, pwProfile, crs);
			else if(pwProfile.GeneratorType == PasswordGeneratorType.Custom)
				e = GenerateCustom(psOutBuffer, pwProfile, crs, pwAlgorithmPool);
			else { Debug.Assert(false); }

			return e;
		}