Msa cryptage non reversible par matrice semi-aléatoire

Soyez le premier à donner votre avis sur cette source.

Snippet vu 5 169 fois - Téléchargée 16 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
3793
Date d'inscription
samedi 22 décembre 2007
Statut
Membre
Dernière intervention
3 juin 2016
6 -
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 -
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
Modérateur
Dernière intervention
20 juin 2013
42 -
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
478
Date d'inscription
mercredi 7 août 2002
Statut
Membre
Dernière intervention
10 juin 2015
-
Milles excuses. Il faut tester avec des chaînes de 65536 caractères (256*256 = taille de la matrice)
cs_Warny
Messages postés
478
Date d'inscription
mercredi 7 août 2002
Statut
Membre
Dernière intervention
10 juin 2015
-
@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...

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.