Cryptage par la méthode de vigenere

Commenter

Contenu du snippet

J'ai trouvé sur le net, une méthode de cryptage : Le chiffre de Vigenere --> http://www.bibmath.net/crypto/poly/vigenere.php3

C'est à partir de cette page que j'ai concu cette classe. J'ai entendu le codage aux 65536 caractères existant, le tableau de Vigenere ne fait donc plus 26*26 mais 65536*65536 =2^32

Merci à SimonKari.

J'ai laissé l'ancienne version qui ressemble un peu plus au carré de Vigenere

Source / Exemple : 


#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

    }
}

Conclusion :


J'ai utilisé VC# 2005 Express Edition pour faire ce code, je pense que ca devrait qd meme fonctionner avec la framework 1.1 si c'est pas le cas faites le moi savoir

c'est la premiere fois que je codais en C# donc c'est possible que vous voyez des trucs farfelus, si c'est le cas, merci de me le dire.

j'aimerais avoir vos avis sur cette simplissime classe aussi bien sur cette classe que sur ma facon de codé en C#

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (jesusonline)