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());

            if (!PwGenerator.PrepareCharSet(pcs, pwProfile))
            {
                return(PwgError.InvalidCharSet);
            }

            char[] v = new char[pwProfile.Length];
            try
            {
                for (int i = 0; i < v.Length; ++i)
                {
                    char ch = PwGenerator.GenerateCharacter(pcs, crsRandomSource);
                    if (ch == char.MinValue)
                    {
                        return(PwgError.TooFewCharacters);
                    }

                    v[i] = ch;
                    if (pwProfile.NoRepeatingCharacters)
                    {
                        pcs.Remove(ch);
                    }
                }

                byte[] pbUtf8 = StrUtil.Utf8.GetBytes(v);
                psOut = new ProtectedString(true, pbUtf8);
                MemUtil.ZeroByteArray(pbUtf8);
            }
            finally { MemUtil.ZeroArray <char>(v); }

            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)
                {
                    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);
        }
Esempio n. 3
0
        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 == '^')
                {
                    ch = csStream.ReadChar();
                    if (ch == char.MinValue)                    // ^ at the end
                    {
                        vGenerated.AddLast('^');
                        break;
                    }

                    if (bInCharSetDef)
                    {
                        pcsCustom.Remove(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);
        }
        internal static PwgError Generate(out ProtectedString psOut,
                                          PwProfile pwProfile, CryptoRandomStream crsRandomSource)
        {
            psOut = ProtectedString.Empty;

            string strPattern = pwProfile.Pattern;

            if (string.IsNullOrEmpty(strPattern))
            {
                return(PwgError.Success);
            }

            CharStream        cs          = new CharStream(strPattern);
            LinkedList <char> llGenerated = new LinkedList <char>();
            PwCharSet         pcs         = new PwCharSet();

            while (true)
            {
                char ch = cs.ReadChar();
                if (ch == char.MinValue)
                {
                    break;
                }

                pcs.Clear();

                if (ch == '\\')
                {
                    ch = cs.ReadChar();
                    if (ch == char.MinValue)
                    {
                        return(PwgError.InvalidPattern);
                    }

                    pcs.Add(ch);                     // Allow "{...}" support and char check
                }
                else if (ch == '[')
                {
                    if (!ReadCustomCharSet(cs, pcs))
                    {
                        return(PwgError.InvalidPattern);
                    }
                }
                else
                {
                    if (!pcs.AddCharSet(ch))
                    {
                        return(PwgError.InvalidPattern);
                    }
                }

                int nCount = 1;
                if (cs.PeekChar() == '{')
                {
                    nCount = ReadCount(cs);
                    if (nCount < 0)
                    {
                        return(PwgError.InvalidPattern);
                    }
                }

                for (int i = 0; i < nCount; ++i)
                {
                    if (!PwGenerator.PrepareCharSet(pcs, pwProfile))
                    {
                        return(PwgError.InvalidCharSet);
                    }
                    if (pwProfile.NoRepeatingCharacters)
                    {
                        foreach (char chUsed in llGenerated)
                        {
                            pcs.Remove(chUsed);
                        }
                    }

                    char chGen = PwGenerator.GenerateCharacter(pcs,
                                                               crsRandomSource);
                    if (chGen == char.MinValue)
                    {
                        return(PwgError.TooFewCharacters);
                    }

                    llGenerated.AddLast(chGen);
                }
            }

            if (llGenerated.Count == 0)
            {
                return(PwgError.Success);
            }

            char[] v = new char[llGenerated.Count];
            llGenerated.CopyTo(v, 0);

            if (pwProfile.PatternPermutePassword)
            {
                PwGenerator.Shuffle(v, crsRandomSource);
            }

            byte[] pbUtf8 = StrUtil.Utf8.GetBytes(v);
            psOut = new ProtectedString(true, pbUtf8);
            MemUtil.ZeroByteArray(pbUtf8);

            MemUtil.ZeroArray <char>(v);
            return(PwgError.Success);
        }