Exemple #1
0
        /// <summary>
        /// Merges the given string into the  "formatted_dest" pattern using the
        /// set of provided characters.
        /// </summary>
        /// <param name="inputString"></param>
        /// <param name="parsedInput"></param>
        /// <param name="padCharacter"></param>
        /// <returns></returns>
        private string MergeToFormattedOutput(string inputString, FpeParseModel parsedInput, string padCharacter)
        {
            var ptChars    = parsedInput.StringTemplate.ToCharArray();
            var inputChars = inputString.ToCharArray();

            var d       = ptChars.Length - 1;
            var s       = inputString.Length - 1;
            var padChar = padCharacter.ToCharArray()[0];

            while (s >= 0 && d >= 0)
            {
                // Find the first available destination character
                while (d >= 0 && ptChars[d] != padChar)
                {
                    d--;
                }

                // Copy the encrypted text into the formatted output string
                if (d >= 0)
                {
                    ptChars[d] = inputChars[s];
                }
                s--;
                d--;
            }

            return(new string(ptChars));
        }
Exemple #2
0
        private FpeParseModel ParseInput(string input, FfsConfigurationResponse ffs, bool encrypt)
        {
            var inputRgxPattern   = $"[{RegexEscape(ffs.InputCharacters)}]";
            var firstCharacter    = ffs.OutputCharacters.Substring(0, 1);
            var invalidRgxPattern = $"[{RegexEscape(ffs.InputCharacters)}{RegexEscape(ffs.Passthrough)}]";

            if (!encrypt)
            {
                inputRgxPattern   = $"[{RegexEscape(ffs.OutputCharacters)}]";
                firstCharacter    = ffs.InputCharacters.Substring(0, 1);
                invalidRgxPattern = $"[{RegexEscape(ffs.OutputCharacters)}{RegexEscape(ffs.Passthrough)}]";
            }

            var inputRgx     = new Regex(inputRgxPattern);
            var inputMatches = inputRgx.Matches(input);

            var formattedPassthroughCharacters = Regex.Replace(input, inputRgxPattern, firstCharacter);

            if (encrypt)
            {
                var             invalidRgx   = new Regex(invalidRgxPattern);
                MatchCollection invalidMatch = invalidRgx.Matches(input);
                if (invalidMatch.Count != input.Length)
                {
                    throw new ArgumentOutOfRangeException("invalid character found in the input");
                }
            }

            var inputSb = new StringBuilder();

            foreach (Match group in inputMatches)
            {
                inputSb.Append(group.Value);
            }

            var result = new FpeParseModel
            {
                StringTemplate = formattedPassthroughCharacters,
                Trimmed        = inputSb.ToString(),
            };

            return(result);
        }