Msa cryptage non reversible par matrice semi-aléatoire

Soyez le premier à donner votre avis sur cette source.

Snippet vu 5 680 fois - Téléchargée 19 fois

Contenu du snippet

Petit algo de cryptage par cryptage semi-aléatoire
je l'ai tester avec plusieur chaine tres ressenblante , et je n'ai pas trouvé de collision, ni de bug

exemple :
Texte original : aa
Resultat : H-D9-E/CD/D/9C/E

Texte original : bb
Resultat : I+E=+F*DE*E*=D*F

Texte original : ab
Resultat : H+D=-F/DD*D*9D/F

Texte original : ba
Resultat : I-E9+E*CE/E/=C*E

Texte original : poiuytreza
Resultat : Yb29fYtV2/SjrVmI

Texte original : pzertyuiop
Resultat : 1fRibVo0RkSum0pM

Source / Exemple :


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

namespace YohanFrameWork.Security
{
    public static class YFW_MSA
    {

        private static Char GetChatAtPos(int pos)
        {
            String s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789=/*-+.";
            return s[pos % s.Length];
        }

        /// <summary>
        /// Creation d'une matrice de 256 * 256
        /// </summary>
        /// <param name="target">Chaine a crypter</param>
        /// <returns></returns>
        private static Int32[,] Matrice(String target)
        {
            Int32[,] Matrice = new Int32[256, 256];
            int posInTarget = 0;
            for (int i = 0; i < 256; i++)
            {
                for (int j = 0; j < 256; j++)
                {
                    // A chaque élément de la matrice , on ajoute la valeur de i * j
                    Matrice[i, j] = target[posInTarget] + (i * j);

                    if (++posInTarget >= target.Length)
                        posInTarget = 0;
                }
            }
            return Matrice;
        }

        /// <summary>
        /// Divise la matrice par deux et opére un xor
        /// </summary>
        /// <param name="target"></param>
        /// <returns></returns>
        private static Int32[,] ComputeMatrice(Int32[,] target)
        {
            if (target.GetLength(0) < 8)
                return target;

            // Creation d'une nouvelle matrice de taille inferieur de 4 par rapport a target
            Int32[,] matrice = new Int32[target.GetLength(0) / 2, target.GetLength(1) / 2];

            for (int i = 0; i < matrice.GetLength(0); i++)
            {
                for (int j = 0; j < matrice.GetLength(1); j++)
                {
                    matrice[(matrice.GetLength(0) - 1) - i, (matrice.GetLength(1) - 1) - j] ^= target[(target.GetLength(0) / 2) + i, (target.GetLength(1) / 2) + j];
                }
            }

            return matrice;
        }

        /// <summary>
        /// Crypte la chaine sur un algo a  matice semi-aléatoire ( ce n'est pas reversible )
        /// </summary>
        /// <param name="target"></param>
        /// <returns></returns>
        public static String MSA_Crypte(this String target)
        {
            Int32[,] matrice = Matrice(target);

            // Reduction de la matrice a 4 * 4
            while (matrice.GetLength(0) > 4 && matrice.GetLength(1) > 4)
            {
                matrice = ComputeMatrice(matrice);
            }
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < 4; i++)
            {
                for (int j = 0; j < 4; j++)
                {
                    sb.Append(GetChatAtPos(matrice[i, j]));
                }
            }
            return sb.ToString();
        }
    }
}

Conclusion :


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using YohanFrameWork.Security;

namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
try
{
string s = null;
s = @"aa";
Console.WriteLine("Texte original : {0}\nResultat : {1}\n", s, s.MSA_Crypte());

s = @"bb";
Console.WriteLine("Texte original : {0}\nResultat : {1}\n", s, s.MSA_Crypte());

s = @"ab";
Console.WriteLine("Texte original : {0}\nResultat : {1}\n", s, s.MSA_Crypte());

s = @"ba";
Console.WriteLine("Texte original : {0}\nResultat : {1}\n", s, s.MSA_Crypte());

s = @"poiuytreza";
Console.WriteLine("Texte original : {0}\nResultat : {1}\n", s, s.MSA_Crypte());

s = @"pzertyuiop";
Console.WriteLine("Texte original : {0}\nResultat : {1}\n", s, s.MSA_Crypte());

}
catch (ArgumentException ex )
{

Console.WriteLine(ex.Message);
}
Console.Read();
}
}
}

A voir également

Ajouter un commentaire Commentaires
Bacterius Messages postés 3792 Date d'inscription samedi 22 décembre 2007 Statut Membre Dernière intervention 3 juin 2016 9
13 juil. 2010 à 06:29
Non, c'est irréversible en général car le domaine (ensemble d'entrée) est plus grand que le codomaine (ensemble de sortie).

Toutefois il me semble relativement aisé de trouver une collision sur un algorithme aussi simple, une attaque algébrique est triviale ici. Essentiellement le problème est de trouver deux matrices qui produisent la même semimatrice après réduction, ce qui me semble peu ardu étant donné la complexité de la fonction de réduction.

Développer des algorithmes cryptographiques en tant qu'amateur peut être intéressant (bien sûr il ne faut pas les utiliser pour un usage sérieux mais juste pour le fun), car il faut développer des techniques de construction et d'optimisation afin de rendre l'algorithme suffisamment performant niveau cryptographique et informatique (un méga algo qui tourne à 1 ko/s ne sert à rien sauf dans des cas très particuliers, mais un algo peu sûr a beau tourner à 4 Go/s, il ne sert à rien de toute façon).

Cordialement, Bacterius !
yohan49 Messages postés 380 Date d'inscription samedi 22 janvier 2005 Statut Membre Dernière intervention 13 août 2011 7
24 juin 2010 à 17:26
Lol BiDou , tu ma devancer de deux seconde , c justement ce que j'allait dire ! implementer des algos non tester dans des appliquations n'est pas a faire ! moi je cherche juste a reflechir au systeme qui pourrait etre fait :)
cs_Bidou Messages postés 5487 Date d'inscription dimanche 4 août 2002 Statut Membre Dernière intervention 20 juin 2013 59
24 juin 2010 à 17:23
C'est bien pour s'amuser le week-end, effectivement, mais personne de sérieux en entreprise prendrait le risque d'implémenter une chose pareille! non?

Mon message était donc là pour prévenir les éventuelles personnes qui fonceraient tête baissées...
cs_Warny Messages postés 473 Date d'inscription mercredi 7 août 2002 Statut Membre Dernière intervention 10 juin 2015
24 juin 2010 à 17:06
Milles excuses. Il faut tester avec des chaînes de 65536 caractères (256*256 = taille de la matrice)
cs_Warny Messages postés 473 Date d'inscription mercredi 7 août 2002 Statut Membre Dernière intervention 10 juin 2015
24 juin 2010 à 17:02
@Bidou : Je ne suis pas d'accord avec toi sur ce point. Proposer un tel algo pour le sport me paraît être bonne une chose. Il est néanmoins important de le préciser.

@yohan49 : un tel algo ne correspond pas à du cryptage, mais à du hashage. Le cryptage sert à rendre illisible pour le commun des mortel, alors que le hashage sert à transporter des données de comparaisons (et dans certain cas à générer des séries aléatoires). Comme il s'agit d'une fonction de hashage, pour bien faire, tu devrais implémenter l'interface des fonctions de hashages.
Sinon pour la ritique de l'algo en lui même. utiliser une matrice de 256*256 d'entier sur 4 octets me paraît un peu lourd.
Pour l'attaque, la taille de la matrice de départ me fait penser qu'en soumettant des chaînes de 262144 caractères similaires, il doit y avoir des collisions des parties du hash. A voir...
Afficher les 8 commentaires

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.