Fejl ved generering af nøgle / brug af genereret nøgle

Jeg er noget skeptisk overfor SetLegalSize med bytes og laengde over 8.

Proev og kig paa output fra dette program:

using System;
using System.Security.Cryptography;

namespace E
{
    public class Program
    {
        public static string SetLegalLength(string inString, int minSize, int maxSize,
                                    int blockSize, bool asBytes)
        {
            int bitFactor = asBytes ? 8 : 1;
            string tmpString = inString;
            int tmpSize = tmpString.Length * bitFactor;
            if (tmpSize > maxSize)
            {
                // Extract maximum size allowed
                tmpString = tmpString.Substring(0, maxSize / bitFactor);
            }
            else if (tmpSize < maxSize)
            {
                // Set valid size
                int validSize = (tmpSize <= minSize) ? minSize :
                                (tmpSize - tmpSize % blockSize) + blockSize;
                if (tmpSize < validSize)
                {
                    // Pad the key with asterisk to make up the size
                    tmpString = tmpString.PadRight(validSize / bitFactor, '*');
                }
            }
            return tmpString;
        }
        private static void Assert(bool condition, string message)
        {
            if(!condition) throw new ApplicationException(message);
        }
        public static string SpecialPad(string inString, int minSize, int maxSize, int multiplaSize, bool sizeInBits)
        {
            Assert(minSize <= maxSize, "minSize must be less than or equal maxSize");
            Assert(minSize % multiplaSize == 0, "minSize must be multipla of multiplaSize");
            Assert(maxSize % multiplaSize == 0, "maxSize must be multipla of multiplaSize");
            Assert(!sizeInBits || minSize % 8 == 0, "minSize in bits must be multipla of 8");
            Assert(!sizeInBits || maxSize % 8 == 0, "maxSize in bits must be multipla of 8");
            Assert(!sizeInBits || multiplaSize % 8 == 0, "multiplaSize in bits must be multipla of 8");
            int scale = sizeInBits ? 8 : 1;
            int size = inString.Length;
            size = Math.Max(size, minSize/scale);
            size = Math.Min(size, maxSize/scale);
            size = ((size - 1) / (multiplaSize/scale) + 1) * (multiplaSize/scale);
            return inString.PadRight(maxSize/scale, '*').Substring(0, size);
        }
        public static void Main(string[] args)
        {
            for(int i = 1; i <= 16; i++)
            {
                string salt = "".PadRight(i, 'a');
                Console.WriteLine(salt);
                string saltLegal = SetLegalLength(salt, 8, 256, 1, false);
                Console.WriteLine(saltLegal);
                string saltPad = SpecialPad(salt, 8, 256, 1, false);
                Console.WriteLine(saltPad);
            }
            SymmetricAlgorithm symAlgo = new RijndaelManaged();
            for(int i = 1; i <= 16; i++)
            {
                string password = "".PadRight(i, 'b');
                Console.WriteLine(password);
                string passwordLegal = SetLegalLength(password, symAlgo.LegalKeySizes[0].MinSize,
                                        symAlgo.LegalKeySizes[0].MaxSize,
                                        symAlgo.LegalKeySizes[0].SkipSize,
                                        true);
                Console.WriteLine(passwordLegal);
                string passwordPad = SpecialPad(password, symAlgo.LegalKeySizes[0].MinSize,
                                        symAlgo.LegalKeySizes[0].MaxSize,
                                        symAlgo.LegalKeySizes[0].SkipSize,
                                        true);
                Console.WriteLine(passwordPad);
            }
            Console.ReadKey();
        }
    }
}