microdevweb a écrit :Je suis conscient que cette méthode n'est peut'être pas la plus efficace et q'un hachage doit l'être bien plus mais malheureusement à sens unique.
Je suis preneur d'autres possibilités et souhaite bon courage à celui qui voudrais décrypter ce type de sécurité sans la clé.
Maintenant il à toujours moyen de faire mieux ça c'est sure.
Vu que tu n'a pas l'air de prendre conscience de l'absence de sécurité de ton code, voici un exemple.
(Je me suis permis de refaire la fonction de chiffrement pour externaliser la clef et la rendre fonctionnelle avec n'importe quel type de données)
Code : Tout sélectionner
EnableExplicit
Procedure UseMask(*data, *mask, size)
Protected offset.i = 0
Protected dataq.q, maskq.q
; On encode les permiers octets 8 par 8 (c'est plus rapide)
While (offset + 8) <= Size
dataq = PeekQ(*data + offset)
maskq = PeekQ(*mask + offset)
dataq ! maskq
PokeQ(*data + offset, dataq)
offset + 8
Wend
; On termine les derniers octets 1 par 1 pour ne pas faire de dépassement de mémoire
While offset <= Size
dataq = PeekB(*data + offset)
maskq = PeekB(*mask + offset)
dataq ! maskq
PokeB(*data + offset, dataq)
offset + 1
Wend
EndProcedure
Procedure Demo1()
Debug "Demo1()"
; J'externalise la clef car elle n'a rien à faire dans la procédure de chiffrement
Protected key.s="AsOfJvmzaNfDesFOmZpbNwKs"
Protected code.s
code = "mh6589"
Debug "CODE AVANT <<"+code+">>"
UseMask(@code, @key, StringByteLength(code))
Debug "CODE CRYPTÉ <<"+code+">>"
UseMask(@code, @key, StringByteLength(code))
Debug "CODE DÉCRYPTÉ <<"+code+">>"
code = "nous somme tous pb"
Debug "CODE AVANT <<"+code+">>"
UseMask(@code, @key, StringByteLength(code))
Debug "CODE CRYPTÉ <<"+code+">>"
UseMask(@code, @key, StringByteLength(code))
Debug "CODE DÉCRYPTÉ <<"+code+">>"
code = "_gfgfgOpm_trtrtr"
Debug "CODE AVANT <<"+code+">>"
UseMask(@code, @key, StringByteLength(code))
Debug "CODE CRYPTÉ <<"+code+">>"
UseMask(@code, @key, StringByteLength(code))
Debug "CODE DÉCRYPTÉ <<"+code+">>"
Debug "Attention c'est bogué si le mot de passe à un caractère en commun avec la clef :"
code = "_sfgfgOpm_trtrtr"
Debug "CODE AVANT <<"+code+">>"
UseMask(@code, @key, StringByteLength(code))
Debug "CODE CRYPTÉ <<"+code+">>"
UseMask(@code, @key, StringByteLength(code))
Debug "CODE DÉCRYPTÉ <<"+code+">>"
Debug ""
EndProcedure
Procedure Demo2()
Debug "Demo2()"
; J'externalise la clef car elle n'a rien à faire dans la procédure de chiffrement
Protected key.s="AsOfJvmzaNfDesFOmZpbNwgJqlP" ; J'ai légèrement allongé la clef pour cet exemple
Debug "Voila pourquoi il ne faut pas réutiliser le même masque :"
Protected code1.s = "Tu ne me trouveras pas"
Debug "CODE1 AVANT <<"+code1+">>"
UseMask(@code1, @key, StringByteLength(code1))
Debug "CODE1 CRYPTÉ <<"+code1+">>"
Protected code2clair.s = "nous allons vérifier ça..." ; code2clair ne doit pas être plus court que code1
Protected code2crypt.s = code2clair
Debug "CODE2 AVANT <<"+code2clair+">>"
UseMask(@code2crypt, @key, StringByteLength(code2clair))
Debug "CODE2 CRYPTÉ <<"+code2crypt+">>"
Debug "CODE1 TOUJOURS CRYPTÉ <<"+code1+">>"
UseMask(@code1, @code2crypt, StringByteLength(code2clair));
UseMask(@code1, @code2clair, StringByteLength(code2clair));
Debug "CODE1 HACKÉ <<"+code1+">>"
Debug ""
EndProcedure
Demo1()
Demo2()
Explications du bug :
Si la chaîne à encoder possède un caractère en commun avec la clé, cela donne le caractère nul (que des zéros). Or ce caractère sert à indiquer une fin de chaîne. Toutes les opérations suivantes voient donc la chaîne comme étant plus courte qu'elle ne devrait l'être.
Comment le hack fonctionne :
La fonction XOR binaire possède trois propriétés singulières :
- variableA XOR variableA = 0 (C'est ce qui cause le bug du dessus)
- variableA XOR 0 = variableA
- c'est une opération commutative
Dans notre cas on à :
- code1 (crypté) = code1 XOR clef
- code2crypt = code2clair XOR clef (<=> clef XOR code2clair)
Le hack fait :
- (code1 (crypté) XOR code2crypt) XOR code2clair
Si on remplace par les valeurs cela donne :
((code1 XOR clef) XOR (clef XOR code2clair)) XOR code2clair
Comme c'est une opération commutative, on peut faire sauter toutes les parentheses, mettre les opérandes dans l'ordre de notre choix et faire les opérations dans l'ordre que l'on veut:
code1 XOR (clef XOR clef) XOR (code2clair XOR code2clair)
Je vous laisse simplifier
Édit : Amémioration et correction du texte de débogage