jme sens 1 peu con lol

jme sens 1 peu con lol - Java - Programmation

Marsh Posté le 22-03-2007 à 03:37:04    

voila bon jme presente... je sui etudiant en 2eme annee de MASS mais je fais aussi de la programmation JAVA, hier soir je sais pa ski mes passé par la tete :pt1cable:  mais j'ai décidé de faire un peu de cryto  :lol: lol :lol: .
ok voila je vous mets le code source la mais je sens ke ca va etre un peu basique pr vous alors riez pas trop :lol:  :sweat:  
 
 
 
/*
 * Encript.java
 *
 * Created on 21 mars 2007, 22:56
 *
 * To change this template, choose Tools | Options and locate the template under
 * the Source Creation and Management node. Right-click the template and choose
 * Open. You can then make changes to the template in the Source Editor.
 */
 
package encrypt;
 
/**
 *
 * @author XXX
 */
public class Encrypt {
    static char[] alphabet;
    static char[] newAlphabet;
    static int[] newAlphabet2;
    /** Creates a new instance of Encript */
    public Encrypt(int i,char[] texte){
        create(i);
        int pos;
        for (int j = 0 ; j<texte.length;j++){
            pos=indexOf(texte[j],alphabet);
            texte[j]=newAlphabet[pos];
        }
    }
    public void decrypt(char[] texte){
        int pos;
        for(int i=0;i<texte.length;i++){
            pos=indexOf(texte[i],newAlphabet);
            texte[i]=alphabet[pos];
        }
}
    public int indexOf(char c,char[] t){
        for(int i = 0 ; i<t.length ; i++)
            if(t[i]==c)
                return i;
        return -1;
    }
    public void create(int k){
        //alphabet
        String liste = "abcdefghijklmnopqrstuvwxyz1234567890 -éABCDEFGHIJKLMNOPQRSTUVWXYZ&²~#'{}()[]|è`_ç^à@°$£¤^¨<>,?;./:!§ù%*µ";
        alphabet = new char[liste.length()];
        for(int i = 0 ; i<liste.length();i++)
            alphabet[i]=liste.charAt(i);
        //new alphabet
        newAlphabet = new char[liste.length()];
        for(int i = 0 ; i<newAlphabet.length;i++)
            newAlphabet[(i+k)%alphabet.length]=alphabet[i];
        //new alphabet2
        newAlphabet2 = new int[liste.length()];
        for(int i = 0 ; i<newAlphabet2.length;i++)
            newAlphabet2[i]=newAlphabet[i];
    }
    public static char[] toCharArray(String s){
        char[] c =new char[s.length()];
        for(int i = 0 ; i<s.length() ; i++){
            c[i]=s.charAt(i);
        }
        return c;
    }
    public static void main(String[] args) {
        int p=33;
        String s = "trop choutte on dirait un vrai code lol"+" "+p;
        char[] r=toCharArray(s);
        Encrypt e=new Encrypt(p,r);
        System.out.println(alphabet.length);
        /*for(int i = 0 ; i<alphabet.length;i++)
            System.out.print(alphabet[i]);
        System.out.println();
        for(int i = 0 ; i<alphabet.length;i++)
            System.out.print(newAlphabet[i]);
        System.out.println();
        for(int i = 0 ; i<alphabet.length;i++)
            System.out.print(newAlphabet2[i]+" " );
        */
        for(int i = 0 ; i<r.length;i++)
            System.out.print(r[i]);
        System.out.println();
        System.out.println("p="+p);
        e.decrypt(r);
        for(int i = 0 ; i<r.length;i++)
            System.out.print(r[i]);
    }
}
 
 
 
 
ce que j'ai fait est tres con... j'ai juste crée une liste avec tous les caracteres possibles, je l'ai "translaté" d'une valeur p que je choisis et qui sera ma clé et ensuite j'ai utilisé cette nouvelle liste "translatée" pour coder ma chaine de caracteres.
 
je voudrais savoir ce ke vs en pensez tt dabord et ensuite quelles sont d'après vous les modifications ou les amelioration a apporter  :sweat:  :sweat:

Reply

Marsh Posté le 22-03-2007 à 03:37:04   

Reply

Marsh Posté le 24-03-2007 à 06:56:26    

personne pr m'aider? :-(

Reply

Marsh Posté le 24-03-2007 à 11:42:29    

utilise les balises deja  
 
comme ca :  

Code :
  1. int main(){
  2.   return 0;
  3. }

Reply

Marsh Posté le 28-03-2007 à 17:15:27    

he ben heuresement que les procédés de crypto ne sont pas aussi banales  ! :lol:  
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
[:dehors]

Reply

Marsh Posté le 28-03-2007 à 17:44:38    

bah c'est basique, mais c'est déjà pas mal ;)
 
une autre solution que je m'étais amusé à faire, toute aussi banale, c'était encrypter avec mot de passe, en additionnant le code asci de chaque lettres du mot de passe une à une avec le texte... pas clair
 


[T]toto va à la plage
[P]azerty


 
=> j'ajoute 'a' à 't' => ça donne le premier caractère
=> j'ajoute 'z' à 'o' => ça me donne le second
=> et ainsi de suite. lorsque j'ai fini toutes les lettres du mot de passe, je reprend la séquence des lettres du mot de passe depuis 0
 
=> l'intérêt, c'est que ça prends un millième de secondes de plus à cracker ;)
 
ensuite, un système classique consiste à reprendre une approche que je trouve similaire à celle de huffman (compression) mais en l'inversant, et, au contraire, en gonflant la taille du fichier :
 
par exemple, pour une encryption sur 128 bits
 
"bonjour"
 
=> je compte chaque caractère différent
b = 1
o = 2
n = 1
j = 1
u = 1
r = 1
 
Je prends réparti de façon homongène mes caractères sur l'ensemble des valeurs possible de 0 à 2^127
 
=> ensuite, je remplace aléatoirement les caractères de mon texte par des membres de chaque plage correspondant à chaque caractère
 
la clé c'est juste la liste des indices de tes caractères trouvés.
 
en l'améliorant un peu, ce système est déjà bien plus difficile à cracker, puisqu'un même caractère peut avoir un (très) grand nombre de représentations différentes possibles. et vu que le choix de ses représenations est en fonction du nombre d'occurences, ça te donne un fichier en résultat totalement homogène : impossible de détecter les caractères qui sont souvent présents dans le code.
 
avec ce système par exemple, on sait qu'un fichier HTML commence (normalement) toujours par "<!DOCTYPE " => on sait donc, avec ton système retrouver toutes les occurences de ces lettres en un clin d'oeil. en réfléchissant un peu, on trouve que c'est un bête offset et le tour est joué. avec mon premier système, "azerty" est plus cours que "<!DOCTYPE " donc à nouveau, l'algo est trouvé en un pouillème de secondes.
 
avec le second système par contre, c'est un "miracle" si j'arrive à retrouver d'autres occurences de mes valeurs de remplacement dans le fichier. à partir de là, ça va devenir bonbon ne serait-ce que pour savoir quel algo a été utilisé. quant au brute force... idem, ça commence à devenir chocolat... par contre, si t'as bien suivit, ça multiplie la taille du fichier par 4 ;)
en reprenant toujours le système d'huffman, on peut s'amuser à construire une table de huffman qui monte jusqu'à 128 bits, et répartir toujours de façon proprotionnelle les caractères dedans. là, très franchement, ça commence à devenir très complexe pour le craquer : on doit recréer une table de huffman, et tester un peu toutes les combinaisons de ranges possible. pour un fichier ANSI, no souci, grace au 8° bit de poids fort dans le fichier original, on se rends compte immédiatement des erreurs... mais pour un document binaire...
 
après, je me suis jamais posé la question d'aller plus loin. à la base, y'a des fonctions 3DES et autres dans tous les langages ou presque, donc autant ne pas réinventer la roue ;)


Message édité par MagicBuzz le 28-03-2007 à 17:53:30
Reply

Marsh Posté le 29-03-2007 à 17:15:54    

Pour le fun, je me suis amusé à mettre en place le système, avec une encryption sur 32 bits, et sans utiliser l'arbre de huffman inversé (trop chiant à coder, même si ça doit rendre le code infiniment moins crackable).
 
Le code :
 

Code :
  1. using System;
  2. using System.IO;
  4. namespace crypt
  5. {
  6.     class Program
  7.     {
  8.         static void Main(string[] args)
  9.         {
  10.             string filename = args[0];
  11.             string keyname = args[1];
  12.             string option = args[2];
  14.             if (option == "E" )
  15.             {
  16.                 Encrypt(filename, keyname);
  17.             }
  18.             else
  19.             {
  20.                 Decrypt(filename, keyname);
  21.             }
  22.         }
  24.         static void Encrypt(string filename, string keyname)
  25.         {
  26.             Random rnd = new Random(DateTime.Now.Millisecond);
  27.             byte[] file = File.ReadAllBytes(filename);
  28.             long filesize = file.LongLength;
  29.             byte[] encrypt = new byte[filesize * 4];
  30.             UInt32[] key = new UInt32[256];
  31.             byte[] keyf = new byte[1024];
  33.             for (long i = 0; i < filesize; i++)
  34.             {
  35.                 key[(int)file[i]]++;
  36.             }
  38.             for (int i = 0; i < 256; i++)
  39.             {
  40.                 keyf[i * 4] = (byte)(key[i] % 256);
  41.                 keyf[i * 4 + 1] = (byte)((key[i] / 256) % 256);
  42.                 keyf[i * 4 + 2] = (byte)((key[i] / 65536) % 256);
  43.                 keyf[i * 4 + 3] = (byte)((key[i] / 16777216) % 256);
  44.             }
  46.             for (long i = 0; i < filesize; i++)
  47.             {
  48.                 UInt32 val = (UInt32)(rnd.NextDouble() * (double)key[file[i]]);
  49.                 if (file[i] > 0)
  50.                 {
  51.                     for (int j = file[i] - 1; j >= 0; j--)
  52.                     {
  53.                         val += key[j];
  54.                     }
  55.                 }
  56.                 encrypt[i * 4] = (byte)(val % 256);
  57.                 encrypt[i * 4 + 1] = (byte)((val / 256) % 256);
  58.                 encrypt[i * 4 + 2] = (byte)((val / 65536) % 256);
  59.                 encrypt[i * 4 + 3] = (byte)((val / 16777216) % 256);
  60.             }
  61.             File.WriteAllBytes(filename + ".enc", encrypt);
  62.             File.WriteAllBytes(keyname, keyf);
  63.         }
  65.         static void Decrypt(string filename, string keyname)
  66.         {
  67.             byte[] keyf = File.ReadAllBytes(keyname);
  68.             UInt32[] key = new UInt32[256];
  70.             for (int i = 0; i < 256; i++)
  71.             {
  72.                 key[i] = (UInt32)keyf[i * 4] + ((UInt32)keyf[i * 4 + 1] * 256) + ((UInt32)keyf[i * 4 + 2] * 65536) + ((UInt32)keyf[i * 4 + 3] * 16777216);
  73.             }
  75.             byte[] filef = File.ReadAllBytes(filename);
  76.             byte[] file = new byte[filef.LongLength / 4];
  78.             for (long i = 0, lng = file.LongLength; i < lng; i++)
  79.             {
  80.                 UInt32 val = (UInt32)filef[i * 4] + ((UInt32)filef[(i * 4) + 1] * 256) + ((UInt32)filef[(i * 4) + 2] * 256) + ((UInt32)filef[(i * 4) + 3] * 16777216);
  82.                 for (int j = 0; j < 256; j++)
  83.                 {
  84.                     if (key[j] > val)
  85.                     {
  86.                         file[i] = (byte)j;
  87.                         break;
  88.                     }
  89.                     else
  90.                     {
  91.                         val -= key[j];
  92.                     }
  93.                 }
  94.             }
  96.             File.WriteAllBytes(filename + ".dec", file);
  97.         }
  98.     }
  99. }


 
Comme tu vois, c'est pas très compliqué, et ne plus, ça marche.
Je viens d'essayer d'encrypter un exécutable puis le décrypter, il marche toujours :D
 
Et clairement, vu la tronche du truc encrypté, tu peux courrir pour le décrypter, même si, parceque mes valeurs de remplacement respectent l'ordre de mes bytes, ça reste "relativement aisément" crackable.
 
=> en effet, si les bits de poids fort sont faibles, alors que sais que la valeur du caractère original est proche de 0, et si elle est élevée, je sais qu'elle est proche de 255. Ensuite, un peu de brute force permet de retrouver petit à petit les valeurs des bounds.
 
Par exemple, dans un EXE sous Windows, on a toujours le message "This program can not run in MS DOS mode...". Il est toujours au même endroit. Ca aide bien déjà ;)
 
=> A noter aussi que cet exemple est à titre d'exemple uniquement. Faire du ReadAllBytes sans vérifier avant que le fichier ne fait pas 100 Go c'est mal ;) Dans l'absolu, on utilisera des buffers, et pourquoi pas des threads pour gérer en // la lecture sur le disque, l'écriture, et l'encryption.
 
J'oubliais : à noter aussi que mon exemple est buggé : il ne fait pas ce qu'il est cencé faire : utilise un range de 0 à filesize caractères au lieu de 0 à 2^32 - 1 ;)


Message édité par MagicBuzz le 29-03-2007 à 17:35:03
Reply

Marsh Posté le 03-04-2007 à 15:06:41    

Le même débugé (génération des caractères de remplacement sur l'ensemble UInt32.Min, UInt32.Max) :
 

Code :
  1. using System;
  2. using System.IO;
  4. namespace crypt
  5. {
  6.     class Program
  7.     {
  8.         static void Main(string[] args)
  9.         {
  10.             string filename = args[0];
  11.             string keyname = args[1];
  12.             string option = args[2];
  14.             if (option == "E" )
  15.             {
  16.                 Encrypt(filename, keyname);
  17.             }
  18.             else
  19.             {
  20.                 Decrypt(filename, keyname);
  21.             }
  22.         }
  24.         static void Encrypt(string filename, string keyname)
  25.         {
  26.             Random rnd = new Random(DateTime.Now.Millisecond);
  27.             byte[] file = File.ReadAllBytes(filename);
  28.             long filesize = file.LongLength;
  29.             byte[] encrypt = new byte[filesize * 4];
  30.             UInt32[] key = new UInt32[256];
  31.             byte[] keyf = new byte[1024];
  33.             // Clé
  34.             for (long i = 0; i < filesize; i++)
  35.             {
  36.                 key[(int)file[i]]++;
  37.             }
  39.             // Conversion de la clé dans un format enregistrable sur le disque
  40.             for (int i = 0; i < 256; i++)
  41.             {
  42.                 keyf[i * 4] = (byte)(key[i] % 256);
  43.                 keyf[i * 4 + 1] = (byte)((key[i] / 256) % 256);
  44.                 keyf[i * 4 + 2] = (byte)((key[i] / 65536) % 256);
  45.                 keyf[i * 4 + 3] = (byte)((key[i] / 16777216) % 256);
  46.             }
  48.             // Encryption du fichier en fonction de la clé
  49.             for (long i = 0; i < filesize; i++)
  50.             {
  51.                 UInt32 val = (UInt32)(rnd.NextDouble() * ((double)key[file[i]] * (double)UInt32.MaxValue) / (double)file.LongLength);
  52.                 if (file[i] > 0)
  53.                 {
  54.                     for (int j = file[i] - 1; j >= 0; j--)
  55.                     {
  56.                         val += (UInt32)(((double)key[j] * (double)UInt32.MaxValue) / (double)file.LongLength);
  57.                     }
  58.                 }
  59.                 encrypt[i * 4] = (byte)(val % 256);
  60.                 encrypt[i * 4 + 1] = (byte)((val / 256) % 256);
  61.                 encrypt[i * 4 + 2] = (byte)((val / 65536) % 256);
  62.                 encrypt[i * 4 + 3] = (byte)((val / 16777216) % 256);
  63.             }
  64.             File.WriteAllBytes(filename + ".enc", encrypt);
  65.             File.WriteAllBytes(keyname, keyf);
  66.         }
  68.         static void Decrypt(string filename, string keyname)
  69.         {
  70.             byte[] keyf = File.ReadAllBytes(keyname);
  71.             UInt32[] key = new UInt32[256];
  73.             for (int i = 0; i < 256; i++)
  74.             {
  75.                 key[i] = (UInt32)keyf[i * 4] + ((UInt32)keyf[i * 4 + 1] * 256) + ((UInt32)keyf[i * 4 + 2] * 65536) + ((UInt32)keyf[i * 4 + 3] * 16777216);
  76.             }
  78.             byte[] filef = File.ReadAllBytes(filename);
  79.             byte[] file = new byte[filef.LongLength / 4];
  81.             for (long i = 0, lng = file.LongLength; i < lng; i++)
  82.             {
  83.                 UInt32 val = (UInt32)filef[i * 4] + ((UInt32)filef[(i * 4) + 1] * 256) + ((UInt32)filef[(i * 4) + 2] * 256) + ((UInt32)filef[(i * 4) + 3] * 16777216);
  85.                 for (int j = 0; j < 256; j++)
  86.                 {
  87.                     if ((UInt32)(((double)key[j] * (double)UInt32.MaxValue) / (double)file.LongLength) > val)
  88.                     {
  89.                         file[i] = (byte)j;
  90.                         break;
  91.                     }
  92.                     else
  93.                     {
  94.                         val -= (UInt32)(((double)key[j] * (double)UInt32.MaxValue) / (double)file.LongLength);
  95.                     }
  96.                 }
  97.             }
  99.             File.WriteAllBytes(filename + ".dec", file);
  100.         }
  101.     }
  102. }

Reply

Marsh Posté le 03-04-2007 à 15:18:27    

L'intérêt de ce truc, c'est qu'on génère "à chaque fois" un fichier différent, pour une même clé. Idéal donc pour un échange réseau : même si on envoies plusieurs fois la même information, on oblige un éventuel intru à décortiquer l'info à chaque fois, ce qui rends la tâche d'autant plus hardue : il suffit de noyer l'information importante dans un spam de données redondantes.

Reply

Marsh Posté le 17-04-2007 à 07:15:42    

je drapalise


---------------
Hobby eien ／人◕ ‿‿ ◕人＼
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed