CRYPTAGE PAR LA MÉTHODE DE VIGENERE

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;

#endregion

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string sKey = "Ceci est la chaîne clé";

            string sValue = "Voici le texte à encoder avec quelques caractères pénibles // !=] %ù ô i () \" ";



            Vigenere oVigenere = new Vigenere(sKey);
            Console.WriteLine(sValue);
            Console.WriteLine("donne une fois code : ");
            DateTime dDateDeb = DateTime.Now;
            Console.WriteLine(oVigenere.Encrypt(sValue));
            Console.WriteLine("L'encryptage a duré : " + (DateTime.Now.Subtract(dDateDeb).Ticks / 10000) + " ms");

            Console.ReadLine();

            Console.WriteLine("Verification : ");
            Console.WriteLine(oVigenere.Decrypt(oVigenere.Encrypt(sValue)));
            Console.ReadLine();
        }
    }


    /// <summary>
    /// http://www.bibmath.net/crypto/poly/vigenere.php3
    /// </summary>
    public class Vigenere
    {

        private string key;
        public string Key
        {
            get { return key; }
        }

        public Vigenere(string cle)
        {

            //            //Je code la clé avec une autre clé qui reprend tout les caractères
            //            #region "Mis en place de Alphabet"
            //            StringBuilder _key = new StringBuilder();
            //            for (int i = 0; i < 65535; i++)
            //            {
            //                _key.Append((char)i);
            //            }
            //            key = _key.ToString();
            //            #endregion
            //            key = Encrypt(cle)

            key = cle;

        }

        public string Encrypt(string ChaineaEncoder)
        {
            string encrypt = null;

            for (int i = 0; i < ChaineaEncoder.Length; i++)
            {
                // encrypt += (char)(((short)key[i % key.Length] + (short)ChaineaEncoder[i])%65536);
                // Equivalent à : 
                encrypt += Convert.ToString(Convert.ToChar((Convert.ToInt16(key[i % key.Length]) + Convert.ToInt16(ChaineaEncoder[i])) % 65536));
            }

            return encrypt;
        }

        public string Decrypt(string ChaineaDecrypter)
        {
            string decrypt = null;

            for (int i = 0; i < ChaineaDecrypter.Length; i++)
            {
                // decrypt += (Char)(((short)ChaineaDecrypter[i] - (short)(key[i % key.Length])) % 65536);
                // Equivalent à : 
                decrypt += Convert.ToString(Convert.ToChar(((Convert.ToInt16(ChaineaDecrypter[i]) - Convert.ToInt16(key[i % key.Length])) % 65536)));
            }

            return decrypt;
        }

    }
}



//------------------------ Ancienne Version ---------------------------

#region Using directives

using System;
using System.Collections.Generic;
using System.Text;

#endregion

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string sKey = "Ceci est la clé avec des caractères non valide /+ ";

            string sValue = "Quelle phrase voulait vous encodé ?";

            Vigenere oVigenere = new Vigenere(sKey);
            Console.WriteLine(sValue);
            Console.WriteLine("donne une fois code : ");
            Console.WriteLine(oVigenere.Encrypt(sValue));
            Console.ReadLine();

            Console.WriteLine("Verification : ");
            Console.WriteLine(oVigenere.Encrypt(oVigenere.Decrypt(sValue)));
            Console.ReadLine();
        }
    }


    /// <summary>
    /// http://www.bibmath.net/crypto/poly/vigenere.php3
    /// </summary>
    public class Vigenere
    {

        #region " Constante "

        private const string Alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ";

        #endregion

        #region " Properties "

        private string key;
        public string Key
        {
            get { return key; }
        }

        #endregion

        #region " Constructor "

        /// <summary>
        /// Je définis une clé provisoire pour pouvoir encoder la clé.
        /// J'encode la clé pour deux raisons, il sera ensuite plus difficile de décrypter, et cela resoud les problèmes d'une clé contenant des caractère interdit
        /// </summary>
        /// <param name="cle"></param>
        public Vigenere(string cle)
        {
            key = "Cryptage par algorythme de Vigenere";
            key = Encrypt(cle);
        }

        #endregion

        #region " Encryptage "

        public string Encrypt(string ChaineaEncoder)
        {
            string encrypt = null;

            for (int i = 0; i < ChaineaEncoder.Length; i++)
            {
                char test = CharEncrypt(key[i % key.Length], ChaineaEncoder[i]);
                encrypt += @test;
            }

            return encrypt;
        }

        /// <summary>
        /// S'il existe un caractère invalide il serait remplacé par le caractère d'espacement
        /// </summary>
        /// <param name="X"></param>
        /// <param name="Y"></param>
        /// <returns></returns>
        private char CharEncrypt(char X, char Y)
        {

            byte NumX = (byte)Alphabet.IndexOf(X);
            byte NumY = (byte)Alphabet.IndexOf(Y);
            if (NumY.Equals((byte)255))
            {
                Console.WriteLine("Charactère à encoder invalide : " + Y.ToString());
                NumY = (byte)Alphabet.IndexOf(' ');
            }
            string alphabet;
            alphabet = Alphabet.Substring(NumY) + Alphabet.Remove(NumY);

            return alphabet[NumX];
        }

        #endregion

        #region " Decryptage "

        public string Decrypt(string ChaineaDecrypter)
        {
            string decrypt = null;

            for (int i = 0; i < ChaineaDecrypter.Length; i++)
            {
                char test = CharDecrypt(key[i % key.Length], ChaineaDecrypter[i]);
                decrypt += @test;
            }

            return decrypt;
        }

        private char CharDecrypt(char X, char Result)
        {

            byte NumX = (byte)Alphabet.IndexOf(X);
            byte NumResult = (byte)Alphabet.IndexOf(Result);
            string alphabet;
            alphabet = Alphabet.Substring(NumX) + Alphabet.Remove(NumX);

            return (char)Alphabet[alphabet.IndexOf(Result)];
        }
        #endregion

    }
}