public string Encode(string message)
        {
            if (!_configurated)
            {
                throw new Exception("Not configurated.");
            }

            BitMessage Round(BitMessage mess, BitMessage key)
            {
                BitMessage L = mess.Take(mess.Count() / 2).ToArray();
                BitMessage R = mess.Skip(mess.Count() / 2).ToArray();

                return(R + (L ^ EncoderFunction(R, key)));
            }

            string[] CutString(string input)
            {
                string[] Blocks = new string[(input.Length * Bit.SizeOfChar) / _sizeOfBlock];

                int lengthOfBlock = input.Length / Blocks.Length;

                for (int i = 0; i < Blocks.Length; i++)
                {
                    Blocks[i] = input.Substring
                                    (i * lengthOfBlock, lengthOfBlock);
                }

                return(Blocks);
            }

            message = StringFormat(message);

            _binaryBlocks = CutString(message)
                            .Select(x => BitMessage.Parse(x)).ToArray();

            var bitKey = BitMessage.Parse
                             (KeyFormat(_key, message.Length
                                        / (2 * _binaryBlocks.Length)));

            for (int i = 0; i < _rounds; i++)
            {
                for (int j = 0; j < _binaryBlocks.Length; j++)
                {
                    _binaryBlocks[j] = Round(_binaryBlocks[j], bitKey);
                }

                bitKey = BitMessage.ParseBinary(KeyToNextRound
                                                    (bitKey.ToBinaryString()));
            }

            bitKey = BitMessage.ParseBinary(KeyToPrevRound
                                                (bitKey.ToBinaryString()));

            return(BitMessage.ParseBinary(String
                                          .Concat(_binaryBlocks
                                                  .Select(x => x.ToBinaryString())))
                   .ToString());
        }
Exemplo n.º 2
0
        static void Main(string[] args)
        {
            var ENG_ALPHA = Alphabet.GetMono(MonoAlphabet.ENG);
            var UTF16     = Alphabet.GetMono(MonoAlphabet.UTF16);

            IAlphabetEncoder caesar = EncoderFactory
                                      .CreateEncoder(EncoderType.Caesar)
                                      .SetMonoAlphabet(UTF16)
                                      .Configure(1);

            IAlphabetEncoder trithemius = EncoderFactory
                                          .CreateEncoder(EncoderType.Trithemius)
                                          .SetMonoAlphabet(ENG_ALPHA)
                                          .Configure(2, new Func <int, int>(x => x + 1));

            IAlphabetEncoder vigener = EncoderFactory
                                       .CreateEncoder(EncoderType.Vigenere)
                                       .Configure("Lemon");

            IAlphabetEncoder diffiHelman = EncoderFactory
                                           .CreateEncoder(EncoderType.DiffiHelman)
                                           .Configure(5, 23, new List <int>()
            {
                23, 43
            });
            IAlphabetEncoder elgamal = EncoderFactory
                                       .CreateEncoder(EncoderType.Elgamal)
                                       .Configure(11, 2, 8, 9);

            IAlphabetEncoder des = EncoderFactory
                                   .CreateBitEncoder(BitEncodingType.Des)
                                   .Configure("чр3Ъ");

            Console.WriteLine(caesar.Encode("Azb12365.,&^%$@"));

            Console.WriteLine(trithemius.Decode(trithemius.Encode("Azb")));

            Console.WriteLine(vigener.Encode("ATTACKATDAWN"));
            Console.WriteLine(diffiHelman.Decode(null));
            Console.WriteLine(elgamal.Decode("5"));
            Console.WriteLine(elgamal.Encode("6,9"));

            string input = "Input";

            BitMessage mess   = BitMessage.Parse(input);
            string     binary = mess.ToBinaryString();

            string output = mess.ToString();

            Console.WriteLine($"\n{input}\n{binary}\n{output}");
            byte[] b   = new UnicodeEncoding().GetBytes(des.Encode("Do you know"));
            string str = new UnicodeEncoding().GetString(b);

            Console.WriteLine(str);
            b.ToList().ForEach(x => Console.WriteLine(x));

            Console.ReadLine();
        }
 public BitMessage Encode(BitMessage message)
 => BitMessage.Parse(Encode(message.ToString()));
 public BitMessage Decode(BitMessage message)
 {
     throw new NotImplementedException();
 }
 private BitMessage EncoderFunction(BitMessage b, BitMessage key)
 {
     return(b ^ key);
 }