Cryptage xor

Script:

Code:

/* HEADER: (str word, str key);
 *
 * Description:
 *  Crypte et décrypte une chaine de caractéres.
 *
 * Arguments:
 *  word: La chaine à cryptée ou à décryptée.
 *  key: La clef qui permet de crypter ou de décrypter 'word'.
 *
 * Retour:
 *  La chaine cryptée ou décryptée.
 *
 */

//--- Initialisation ----------
    var length_w, length_k, key, ret, p, i;
        length_w = string_length(argument0);
        length_k = string_length(argument1);
        ret = '';
        p=1;

//--- Cryptage ----------
    for( i=1; i<=length_w; i+=1 ){
        p= p mod length_k ;
        ret+= chr( ord(string_char_at(argument0, i) ) ^ ord( string_char_at(argument1, p) ) );
    }

//--- Retour ----------
    return ret;

Ancienne version (pas optimisée).

Spoiler:

Exemple d'utilisation:
:

Code:

word='Zelda et Link';
key='kjkjhfodifhsjkfsdfhukfhsdfhish';

word = script(word,key );
    show_message(word);

word = script(word,key );
    show_message(word);

Y avais déjà un script comme ça dans cette section :b

Par contre, petit soucis d'opti, je trouve que c'est pas très malin d'allonger ta clé, alors que tu as juste a créer un curseur de position et le faire boucler (prend moins de ram, et surtout bien moins de temps).
Enfin quoi qu'il en soit le cryptage xor c'est vraiment un des trucs les moins efficaces qui soit, surtout si il n'est pas couplé avec une vérification de parité des octets.
(Sinon on peut retrouver très facilement la clé, juste en changeant des valeurs au pif et en regardant ce que ça donne).

Bref il faut voir cet algo comme un chiffrement de césar amélioré. Ça permet de ne pas lire un texte/autre comme ça du premier coup d'œil, mais ça ne sécurise absolument pas les données (dans un jeu/logiciel en tout cas).

Citation :

Y avais déjà un script comme ça dans cette section :b

J'ai cherché avant et j'ai pas trouvé -_- ça m'aurai épargné de l’écrire, grrr.

Citation :

Par contre, petit soucis d'opti, je trouve que c'est pas très malin d'allonger ta clé, alors que tu as juste a créer un curseur de position et le faire boucler (prend moins de ram, et surtout bien moins de temps).

Bah, justement, j'y ai pensé mais j'ai eu un doute sur ce qui était le mieux.
là moi je ne fait qu'une seule opération :

Code:

n=( length div string_length(key) );

Alors que pour boucler le pointeur tu dois faire un modulo à chaque tour ce qui fait autant de calcules que le nombre de caractères à crypter.

Citation :

prend moins de ram

Comment ça?
Je l'utilise pour un crypter des mots pour mes sauvegardes, donc généralement les mots sont plus cour que ma clef.

Tu me conseille quant même de passer par un modulo à chaque tour?

En fait c'est le key+=key qui m'hérisse un peu les poils :b

Oui mais si la clef est plus grande que le mot à crypter l'action n'aura même pas lieu. C'est vraiment pas bien ou c'est tes principes?

En fait les opérations de concaténation de deux string sont plutôt lourdes (ré-allocation de mémoire et tout), alors que si tu utilise juste un curseur qui parcours la clé et fait une boucle, bah tu économise et vitesse et ram.
Imagine le gars qui veux crypter un texte de 100ko avec une clé de 50 octets, il va se retrouver a ré allouer une chaine de caractère de 100ko alors qu'il aurais pu juste utiliser la chaine contenue dans l'argument 0, sans avoir rien a faire x)

Citation :

En fait les opérations de concaténation de deux string sont plutôt lourdes (ré-allocation de mémoire et tout),

Ok ok, je pige ce que tu veux dire, je modifie ça dans la soirée. Merci !

Sinon, l'ancien script si tu veux t'en aider : https://cbna.forumactif.com/t8144-fonctionnel-cryptage-de-string-par-l-algorythme-xor
Et pour la recherche, bah t'avais pas a te prendre la tête, c'était dans ce topic : https://cbna.forumactif.com/t10194-scripts-par-categories
x)

C'est bon ça :

Code:

//--- Initialisation ----------
    var length_w, length_k, key, ret, p, i;
        length_w = string_length(argument0);
        length_k = string_length(argument1);
        ret = '';
        p=1;

//--- Cryptage ----------
    for( i=1; i<=length_w; i+=1 ){
        p= p mod length_k ;
        ret+= chr( ord(string_char_at(argument0, i) ) ^ ord( string_char_at(argument1, p) ) );
    }

//--- Retour ----------
    return ret;

Sur la recherche du forum on ne trouve pas le sujet ... La prochaine fois je regarderai dans ton topic.

Ouep la ça a l'air nickel :b